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

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

package rcommon

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 (
	logging_log "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	monitoring_time_serie "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/time_serie"
	meta_resource "github.com/cloudwan/goten-sdk/meta-service/resources/v1/resource"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
)

// 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 (
	_ = &logging_log.Log{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &monitoring_time_serie.Point{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &meta_resource.Resource{}
)

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

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

type LogCndSpec_FieldPathSelector int32

const (
	LogCndSpec_FieldPathSelectorQuery         LogCndSpec_FieldPathSelector = 0
	LogCndSpec_FieldPathSelectorGroupByLabels LogCndSpec_FieldPathSelector = 1
)

func (s LogCndSpec_FieldPathSelector) String() string {
	switch s {
	case LogCndSpec_FieldPathSelectorQuery:
		return "query"
	case LogCndSpec_FieldPathSelectorGroupByLabels:
		return "group_by_labels"
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", s))
	}
}

func BuildLogCndSpec_FieldPath(fp gotenobject.RawFieldPath) (LogCndSpec_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object LogCndSpec")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "query":
			return &LogCndSpec_FieldTerminalPath{selector: LogCndSpec_FieldPathSelectorQuery}, nil
		case "group_by_labels", "groupByLabels", "group-by-labels":
			return &LogCndSpec_FieldTerminalPath{selector: LogCndSpec_FieldPathSelectorGroupByLabels}, nil
		}
	} else {
		switch fp[0] {
		case "query":
			if subpath, err := BuildLogCndSpecQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &LogCndSpec_FieldSubPath{selector: LogCndSpec_FieldPathSelectorQuery, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object LogCndSpec", fp)
}

func ParseLogCndSpec_FieldPath(rawField string) (LogCndSpec_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildLogCndSpec_FieldPath(fp)
}

func MustParseLogCndSpec_FieldPath(rawField string) LogCndSpec_FieldPath {
	fp, err := ParseLogCndSpec_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type LogCndSpec_FieldTerminalPath struct {
	selector LogCndSpec_FieldPathSelector
}

var _ LogCndSpec_FieldPath = (*LogCndSpec_FieldTerminalPath)(nil)

func (fp *LogCndSpec_FieldTerminalPath) Selector() LogCndSpec_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source LogCndSpec
func (fp *LogCndSpec_FieldTerminalPath) Get(source *LogCndSpec) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case LogCndSpec_FieldPathSelectorQuery:
			if source.Query != nil {
				values = append(values, source.Query)
			}
		case LogCndSpec_FieldPathSelectorGroupByLabels:
			for _, value := range source.GetGroupByLabels() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fp.selector))
		}
	}
	return
}

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

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

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

// GetDefault returns a default value of the field type
func (fp *LogCndSpec_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case LogCndSpec_FieldPathSelectorQuery:
		return (*LogCndSpec_Query)(nil)
	case LogCndSpec_FieldPathSelectorGroupByLabels:
		return ([]string)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fp.selector))
	}
}

func (fp *LogCndSpec_FieldTerminalPath) ClearValue(item *LogCndSpec) {
	if item != nil {
		switch fp.selector {
		case LogCndSpec_FieldPathSelectorQuery:
			item.Query = nil
		case LogCndSpec_FieldPathSelectorGroupByLabels:
			item.GroupByLabels = nil
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fp.selector))
		}
	}
}

func (fp *LogCndSpec_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*LogCndSpec))
}

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

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

func (fp *LogCndSpec_FieldTerminalPath) WithIValue(value interface{}) LogCndSpec_FieldPathValue {
	switch fp.selector {
	case LogCndSpec_FieldPathSelectorQuery:
		return &LogCndSpec_FieldTerminalPathValue{LogCndSpec_FieldTerminalPath: *fp, value: value.(*LogCndSpec_Query)}
	case LogCndSpec_FieldPathSelectorGroupByLabels:
		return &LogCndSpec_FieldTerminalPathValue{LogCndSpec_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fp.selector))
	}
}

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

func (fp *LogCndSpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) LogCndSpec_FieldPathArrayOfValues {
	fpaov := &LogCndSpec_FieldTerminalPathArrayOfValues{LogCndSpec_FieldTerminalPath: *fp}
	switch fp.selector {
	case LogCndSpec_FieldPathSelectorQuery:
		return &LogCndSpec_FieldTerminalPathArrayOfValues{LogCndSpec_FieldTerminalPath: *fp, values: values.([]*LogCndSpec_Query)}
	case LogCndSpec_FieldPathSelectorGroupByLabels:
		return &LogCndSpec_FieldTerminalPathArrayOfValues{LogCndSpec_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *LogCndSpec_FieldTerminalPath) WithIArrayItemValue(value interface{}) LogCndSpec_FieldPathArrayItemValue {
	switch fp.selector {
	case LogCndSpec_FieldPathSelectorGroupByLabels:
		return &LogCndSpec_FieldTerminalPathArrayItemValue{LogCndSpec_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fp.selector))
	}
}

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

type LogCndSpec_FieldSubPath struct {
	selector LogCndSpec_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ LogCndSpec_FieldPath = (*LogCndSpec_FieldSubPath)(nil)

func (fps *LogCndSpec_FieldSubPath) Selector() LogCndSpec_FieldPathSelector {
	return fps.selector
}
func (fps *LogCndSpec_FieldSubPath) AsQuerySubPath() (LogCndSpecQuery_FieldPath, bool) {
	res, ok := fps.subPath.(LogCndSpecQuery_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *LogCndSpec_FieldSubPath) ClearValue(item *LogCndSpec) {
	if item != nil {
		switch fps.selector {
		case LogCndSpec_FieldPathSelectorQuery:
			fps.subPath.ClearValueRaw(item.Query)
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fps.selector))
		}
	}
}

func (fps *LogCndSpec_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*LogCndSpec))
}

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

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

func (fps *LogCndSpec_FieldSubPath) WithIValue(value interface{}) LogCndSpec_FieldPathValue {
	return &LogCndSpec_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *LogCndSpec_FieldSubPath) WithIArrayOfValues(values interface{}) LogCndSpec_FieldPathArrayOfValues {
	return &LogCndSpec_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *LogCndSpec_FieldSubPath) WithIArrayItemValue(value interface{}) LogCndSpec_FieldPathArrayItemValue {
	return &LogCndSpec_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseLogCndSpec_FieldPathValue(pathStr, valueStr string) LogCndSpec_FieldPathValue {
	fpv, err := ParseLogCndSpec_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type LogCndSpec_FieldTerminalPathValue struct {
	LogCndSpec_FieldTerminalPath
	value interface{}
}

var _ LogCndSpec_FieldPathValue = (*LogCndSpec_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'LogCndSpec' as interface{}
func (fpv *LogCndSpec_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *LogCndSpec_FieldTerminalPathValue) AsQueryValue() (*LogCndSpec_Query, bool) {
	res, ok := fpv.value.(*LogCndSpec_Query)
	return res, ok
}
func (fpv *LogCndSpec_FieldTerminalPathValue) AsGroupByLabelsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object LogCndSpec
func (fpv *LogCndSpec_FieldTerminalPathValue) SetTo(target **LogCndSpec) {
	if *target == nil {
		*target = new(LogCndSpec)
	}
	switch fpv.selector {
	case LogCndSpec_FieldPathSelectorQuery:
		(*target).Query = fpv.value.(*LogCndSpec_Query)
	case LogCndSpec_FieldPathSelectorGroupByLabels:
		(*target).GroupByLabels = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fpv.selector))
	}
}

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

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

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

type LogCndSpec_FieldSubPathValue struct {
	LogCndSpec_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ LogCndSpec_FieldPathValue = (*LogCndSpec_FieldSubPathValue)(nil)

func (fpvs *LogCndSpec_FieldSubPathValue) AsQueryPathValue() (LogCndSpecQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(LogCndSpecQuery_FieldPathValue)
	return res, ok
}

func (fpvs *LogCndSpec_FieldSubPathValue) SetTo(target **LogCndSpec) {
	if *target == nil {
		*target = new(LogCndSpec)
	}
	switch fpvs.Selector() {
	case LogCndSpec_FieldPathSelectorQuery:
		fpvs.subPathValue.(LogCndSpecQuery_FieldPathValue).SetTo(&(*target).Query)
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *LogCndSpec_FieldSubPathValue) CompareWith(source *LogCndSpec) (int, bool) {
	switch fpvs.Selector() {
	case LogCndSpec_FieldPathSelectorQuery:
		return fpvs.subPathValue.(LogCndSpecQuery_FieldPathValue).CompareWith(source.GetQuery())
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseLogCndSpec_FieldPathArrayItemValue(pathStr, valueStr string) LogCndSpec_FieldPathArrayItemValue {
	fpaiv, err := ParseLogCndSpec_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type LogCndSpec_FieldTerminalPathArrayItemValue struct {
	LogCndSpec_FieldTerminalPath
	value interface{}
}

var _ LogCndSpec_FieldPathArrayItemValue = (*LogCndSpec_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *LogCndSpec_FieldTerminalPathArrayItemValue) GetSingle(source *LogCndSpec) (interface{}, bool) {
	return nil, false
}

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

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

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

// Contains returns a boolean indicating if value that is being held is present in given 'LogCndSpec'
func (fpaivs *LogCndSpec_FieldSubPathArrayItemValue) ContainsValue(source *LogCndSpec) bool {
	switch fpaivs.Selector() {
	case LogCndSpec_FieldPathSelectorQuery:
		return fpaivs.subPathItemValue.(LogCndSpecQuery_FieldPathArrayItemValue).ContainsValue(source.GetQuery())
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec: %d", fpaivs.Selector()))
	}
}

// LogCndSpec_FieldPathArrayOfValues allows storing slice of values for LogCndSpec fields according to their type
type LogCndSpec_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	LogCndSpec_FieldPath
}

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

func MustParseLogCndSpec_FieldPathArrayOfValues(pathStr, valuesStr string) LogCndSpec_FieldPathArrayOfValues {
	fpaov, err := ParseLogCndSpec_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type LogCndSpec_FieldTerminalPathArrayOfValues struct {
	LogCndSpec_FieldTerminalPath
	values interface{}
}

var _ LogCndSpec_FieldPathArrayOfValues = (*LogCndSpec_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *LogCndSpec_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case LogCndSpec_FieldPathSelectorQuery:
		for _, v := range fpaov.values.([]*LogCndSpec_Query) {
			values = append(values, v)
		}
	case LogCndSpec_FieldPathSelectorGroupByLabels:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *LogCndSpec_FieldTerminalPathArrayOfValues) AsQueryArrayOfValues() ([]*LogCndSpec_Query, bool) {
	res, ok := fpaov.values.([]*LogCndSpec_Query)
	return res, ok
}
func (fpaov *LogCndSpec_FieldTerminalPathArrayOfValues) AsGroupByLabelsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}

type LogCndSpec_FieldSubPathArrayOfValues struct {
	LogCndSpec_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ LogCndSpec_FieldPathArrayOfValues = (*LogCndSpec_FieldSubPathArrayOfValues)(nil)

func (fpsaov *LogCndSpec_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *LogCndSpec_FieldSubPathArrayOfValues) AsQueryPathArrayOfValues() (LogCndSpecQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(LogCndSpecQuery_FieldPathArrayOfValues)
	return res, ok
}

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

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

type LogCndSpecQuery_FieldPathSelector int32

const (
	LogCndSpecQuery_FieldPathSelectorFilter      LogCndSpecQuery_FieldPathSelector = 0
	LogCndSpecQuery_FieldPathSelectorTrigger     LogCndSpecQuery_FieldPathSelector = 1
	LogCndSpecQuery_FieldPathSelectorMinDuration LogCndSpecQuery_FieldPathSelector = 2
)

func (s LogCndSpecQuery_FieldPathSelector) String() string {
	switch s {
	case LogCndSpecQuery_FieldPathSelectorFilter:
		return "filter"
	case LogCndSpecQuery_FieldPathSelectorTrigger:
		return "trigger"
	case LogCndSpecQuery_FieldPathSelectorMinDuration:
		return "min_duration"
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query: %d", s))
	}
}

func BuildLogCndSpecQuery_FieldPath(fp gotenobject.RawFieldPath) (LogCndSpecQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object LogCndSpec_Query")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "filter":
			return &LogCndSpecQuery_FieldTerminalPath{selector: LogCndSpecQuery_FieldPathSelectorFilter}, nil
		case "trigger":
			return &LogCndSpecQuery_FieldTerminalPath{selector: LogCndSpecQuery_FieldPathSelectorTrigger}, nil
		case "min_duration", "minDuration", "min-duration":
			return &LogCndSpecQuery_FieldTerminalPath{selector: LogCndSpecQuery_FieldPathSelectorMinDuration}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object LogCndSpec_Query", fp)
}

func ParseLogCndSpecQuery_FieldPath(rawField string) (LogCndSpecQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildLogCndSpecQuery_FieldPath(fp)
}

func MustParseLogCndSpecQuery_FieldPath(rawField string) LogCndSpecQuery_FieldPath {
	fp, err := ParseLogCndSpecQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type LogCndSpecQuery_FieldTerminalPath struct {
	selector LogCndSpecQuery_FieldPathSelector
}

var _ LogCndSpecQuery_FieldPath = (*LogCndSpecQuery_FieldTerminalPath)(nil)

func (fp *LogCndSpecQuery_FieldTerminalPath) Selector() LogCndSpecQuery_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source LogCndSpec_Query
func (fp *LogCndSpecQuery_FieldTerminalPath) Get(source *LogCndSpec_Query) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case LogCndSpecQuery_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case LogCndSpecQuery_FieldPathSelectorTrigger:
			if source.Trigger != nil {
				values = append(values, source.Trigger)
			}
		case LogCndSpecQuery_FieldPathSelectorMinDuration:
			if source.MinDuration != nil {
				values = append(values, source.MinDuration)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source LogCndSpec_Query
func (fp *LogCndSpecQuery_FieldTerminalPath) GetSingle(source *LogCndSpec_Query) (interface{}, bool) {
	switch fp.selector {
	case LogCndSpecQuery_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case LogCndSpecQuery_FieldPathSelectorTrigger:
		res := source.GetTrigger()
		return res, res != nil
	case LogCndSpecQuery_FieldPathSelectorMinDuration:
		res := source.GetMinDuration()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *LogCndSpecQuery_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case LogCndSpecQuery_FieldPathSelectorFilter:
		return (*logging_log.Filter)(nil)
	case LogCndSpecQuery_FieldPathSelectorTrigger:
		return (*LogCndSpec_Query_TriggerCnd)(nil)
	case LogCndSpecQuery_FieldPathSelectorMinDuration:
		return (*durationpb.Duration)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query: %d", fp.selector))
	}
}

func (fp *LogCndSpecQuery_FieldTerminalPath) ClearValue(item *LogCndSpec_Query) {
	if item != nil {
		switch fp.selector {
		case LogCndSpecQuery_FieldPathSelectorFilter:
			item.Filter = nil
		case LogCndSpecQuery_FieldPathSelectorTrigger:
			item.Trigger = nil
		case LogCndSpecQuery_FieldPathSelectorMinDuration:
			item.MinDuration = nil
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query: %d", fp.selector))
		}
	}
}

func (fp *LogCndSpecQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*LogCndSpec_Query))
}

// IsLeaf - whether field path is holds simple value
func (fp *LogCndSpecQuery_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == LogCndSpecQuery_FieldPathSelectorFilter ||
		fp.selector == LogCndSpecQuery_FieldPathSelectorTrigger ||
		fp.selector == LogCndSpecQuery_FieldPathSelectorMinDuration
}

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

func (fp *LogCndSpecQuery_FieldTerminalPath) WithIValue(value interface{}) LogCndSpecQuery_FieldPathValue {
	switch fp.selector {
	case LogCndSpecQuery_FieldPathSelectorFilter:
		return &LogCndSpecQuery_FieldTerminalPathValue{LogCndSpecQuery_FieldTerminalPath: *fp, value: value.(*logging_log.Filter)}
	case LogCndSpecQuery_FieldPathSelectorTrigger:
		return &LogCndSpecQuery_FieldTerminalPathValue{LogCndSpecQuery_FieldTerminalPath: *fp, value: value.(*LogCndSpec_Query_TriggerCnd)}
	case LogCndSpecQuery_FieldPathSelectorMinDuration:
		return &LogCndSpecQuery_FieldTerminalPathValue{LogCndSpecQuery_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query: %d", fp.selector))
	}
}

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

func (fp *LogCndSpecQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) LogCndSpecQuery_FieldPathArrayOfValues {
	fpaov := &LogCndSpecQuery_FieldTerminalPathArrayOfValues{LogCndSpecQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case LogCndSpecQuery_FieldPathSelectorFilter:
		return &LogCndSpecQuery_FieldTerminalPathArrayOfValues{LogCndSpecQuery_FieldTerminalPath: *fp, values: values.([]*logging_log.Filter)}
	case LogCndSpecQuery_FieldPathSelectorTrigger:
		return &LogCndSpecQuery_FieldTerminalPathArrayOfValues{LogCndSpecQuery_FieldTerminalPath: *fp, values: values.([]*LogCndSpec_Query_TriggerCnd)}
	case LogCndSpecQuery_FieldPathSelectorMinDuration:
		return &LogCndSpecQuery_FieldTerminalPathArrayOfValues{LogCndSpecQuery_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseLogCndSpecQuery_FieldPathValue(pathStr, valueStr string) LogCndSpecQuery_FieldPathValue {
	fpv, err := ParseLogCndSpecQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type LogCndSpecQuery_FieldTerminalPathValue struct {
	LogCndSpecQuery_FieldTerminalPath
	value interface{}
}

var _ LogCndSpecQuery_FieldPathValue = (*LogCndSpecQuery_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Query' as interface{}
func (fpv *LogCndSpecQuery_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *LogCndSpecQuery_FieldTerminalPathValue) AsFilterValue() (*logging_log.Filter, bool) {
	res, ok := fpv.value.(*logging_log.Filter)
	return res, ok
}
func (fpv *LogCndSpecQuery_FieldTerminalPathValue) AsTriggerValue() (*LogCndSpec_Query_TriggerCnd, bool) {
	res, ok := fpv.value.(*LogCndSpec_Query_TriggerCnd)
	return res, ok
}
func (fpv *LogCndSpecQuery_FieldTerminalPathValue) AsMinDurationValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}

// SetTo stores value for selected field for object Query
func (fpv *LogCndSpecQuery_FieldTerminalPathValue) SetTo(target **LogCndSpec_Query) {
	if *target == nil {
		*target = new(LogCndSpec_Query)
	}
	switch fpv.selector {
	case LogCndSpecQuery_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*logging_log.Filter)
	case LogCndSpecQuery_FieldPathSelectorTrigger:
		(*target).Trigger = fpv.value.(*LogCndSpec_Query_TriggerCnd)
	case LogCndSpecQuery_FieldPathSelectorMinDuration:
		(*target).MinDuration = fpv.value.(*durationpb.Duration)
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'LogCndSpecQuery_FieldTerminalPathValue' with the value under path in 'LogCndSpec_Query'.
func (fpv *LogCndSpecQuery_FieldTerminalPathValue) CompareWith(source *LogCndSpec_Query) (int, bool) {
	switch fpv.selector {
	case LogCndSpecQuery_FieldPathSelectorFilter:
		return 0, false
	case LogCndSpecQuery_FieldPathSelectorTrigger:
		return 0, false
	case LogCndSpecQuery_FieldPathSelectorMinDuration:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetMinDuration()
		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 LogCndSpec_Query: %d", fpv.selector))
	}
}

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

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

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

func MustParseLogCndSpecQuery_FieldPathArrayItemValue(pathStr, valueStr string) LogCndSpecQuery_FieldPathArrayItemValue {
	fpaiv, err := ParseLogCndSpecQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type LogCndSpecQuery_FieldTerminalPathArrayItemValue struct {
	LogCndSpecQuery_FieldTerminalPath
	value interface{}
}

var _ LogCndSpecQuery_FieldPathArrayItemValue = (*LogCndSpecQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *LogCndSpecQuery_FieldTerminalPathArrayItemValue) GetSingle(source *LogCndSpec_Query) (interface{}, bool) {
	return nil, false
}

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

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

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

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

func MustParseLogCndSpecQuery_FieldPathArrayOfValues(pathStr, valuesStr string) LogCndSpecQuery_FieldPathArrayOfValues {
	fpaov, err := ParseLogCndSpecQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type LogCndSpecQuery_FieldTerminalPathArrayOfValues struct {
	LogCndSpecQuery_FieldTerminalPath
	values interface{}
}

var _ LogCndSpecQuery_FieldPathArrayOfValues = (*LogCndSpecQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *LogCndSpecQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case LogCndSpecQuery_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*logging_log.Filter) {
			values = append(values, v)
		}
	case LogCndSpecQuery_FieldPathSelectorTrigger:
		for _, v := range fpaov.values.([]*LogCndSpec_Query_TriggerCnd) {
			values = append(values, v)
		}
	case LogCndSpecQuery_FieldPathSelectorMinDuration:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *LogCndSpecQuery_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*logging_log.Filter, bool) {
	res, ok := fpaov.values.([]*logging_log.Filter)
	return res, ok
}
func (fpaov *LogCndSpecQuery_FieldTerminalPathArrayOfValues) AsTriggerArrayOfValues() ([]*LogCndSpec_Query_TriggerCnd, bool) {
	res, ok := fpaov.values.([]*LogCndSpec_Query_TriggerCnd)
	return res, ok
}
func (fpaov *LogCndSpecQuery_FieldTerminalPathArrayOfValues) AsMinDurationArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}

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

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

type LogCndSpecQueryLabelTrigger_FieldPathSelector int32

const (
	LogCndSpecQueryLabelTrigger_FieldPathSelectorKey    LogCndSpecQueryLabelTrigger_FieldPathSelector = 0
	LogCndSpecQueryLabelTrigger_FieldPathSelectorValues LogCndSpecQueryLabelTrigger_FieldPathSelector = 1
)

func (s LogCndSpecQueryLabelTrigger_FieldPathSelector) String() string {
	switch s {
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorKey:
		return "key"
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorValues:
		return "values"
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_LabelTrigger: %d", s))
	}
}

func BuildLogCndSpecQueryLabelTrigger_FieldPath(fp gotenobject.RawFieldPath) (LogCndSpecQueryLabelTrigger_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object LogCndSpec_Query_LabelTrigger")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "key":
			return &LogCndSpecQueryLabelTrigger_FieldTerminalPath{selector: LogCndSpecQueryLabelTrigger_FieldPathSelectorKey}, nil
		case "values":
			return &LogCndSpecQueryLabelTrigger_FieldTerminalPath{selector: LogCndSpecQueryLabelTrigger_FieldPathSelectorValues}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object LogCndSpec_Query_LabelTrigger", fp)
}

func ParseLogCndSpecQueryLabelTrigger_FieldPath(rawField string) (LogCndSpecQueryLabelTrigger_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildLogCndSpecQueryLabelTrigger_FieldPath(fp)
}

func MustParseLogCndSpecQueryLabelTrigger_FieldPath(rawField string) LogCndSpecQueryLabelTrigger_FieldPath {
	fp, err := ParseLogCndSpecQueryLabelTrigger_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type LogCndSpecQueryLabelTrigger_FieldTerminalPath struct {
	selector LogCndSpecQueryLabelTrigger_FieldPathSelector
}

var _ LogCndSpecQueryLabelTrigger_FieldPath = (*LogCndSpecQueryLabelTrigger_FieldTerminalPath)(nil)

func (fp *LogCndSpecQueryLabelTrigger_FieldTerminalPath) Selector() LogCndSpecQueryLabelTrigger_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source LogCndSpec_Query_LabelTrigger
func (fp *LogCndSpecQueryLabelTrigger_FieldTerminalPath) Get(source *LogCndSpec_Query_LabelTrigger) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case LogCndSpecQueryLabelTrigger_FieldPathSelectorKey:
			values = append(values, source.Key)
		case LogCndSpecQueryLabelTrigger_FieldPathSelectorValues:
			for _, value := range source.GetValues() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_LabelTrigger: %d", fp.selector))
		}
	}
	return
}

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

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

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

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

func (fp *LogCndSpecQueryLabelTrigger_FieldTerminalPath) ClearValue(item *LogCndSpec_Query_LabelTrigger) {
	if item != nil {
		switch fp.selector {
		case LogCndSpecQueryLabelTrigger_FieldPathSelectorKey:
			item.Key = ""
		case LogCndSpecQueryLabelTrigger_FieldPathSelectorValues:
			item.Values = nil
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_LabelTrigger: %d", fp.selector))
		}
	}
}

func (fp *LogCndSpecQueryLabelTrigger_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*LogCndSpec_Query_LabelTrigger))
}

// IsLeaf - whether field path is holds simple value
func (fp *LogCndSpecQueryLabelTrigger_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == LogCndSpecQueryLabelTrigger_FieldPathSelectorKey ||
		fp.selector == LogCndSpecQueryLabelTrigger_FieldPathSelectorValues
}

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

func (fp *LogCndSpecQueryLabelTrigger_FieldTerminalPath) WithIValue(value interface{}) LogCndSpecQueryLabelTrigger_FieldPathValue {
	switch fp.selector {
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorKey:
		return &LogCndSpecQueryLabelTrigger_FieldTerminalPathValue{LogCndSpecQueryLabelTrigger_FieldTerminalPath: *fp, value: value.(string)}
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorValues:
		return &LogCndSpecQueryLabelTrigger_FieldTerminalPathValue{LogCndSpecQueryLabelTrigger_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_LabelTrigger: %d", fp.selector))
	}
}

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

func (fp *LogCndSpecQueryLabelTrigger_FieldTerminalPath) WithIArrayOfValues(values interface{}) LogCndSpecQueryLabelTrigger_FieldPathArrayOfValues {
	fpaov := &LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayOfValues{LogCndSpecQueryLabelTrigger_FieldTerminalPath: *fp}
	switch fp.selector {
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorKey:
		return &LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayOfValues{LogCndSpecQueryLabelTrigger_FieldTerminalPath: *fp, values: values.([]string)}
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorValues:
		return &LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayOfValues{LogCndSpecQueryLabelTrigger_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_LabelTrigger: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *LogCndSpecQueryLabelTrigger_FieldTerminalPath) WithIArrayItemValue(value interface{}) LogCndSpecQueryLabelTrigger_FieldPathArrayItemValue {
	switch fp.selector {
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorValues:
		return &LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayItemValue{LogCndSpecQueryLabelTrigger_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_LabelTrigger: %d", fp.selector))
	}
}

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

// LogCndSpecQueryLabelTrigger_FieldPathValue allows storing values for LabelTrigger fields according to their type
type LogCndSpecQueryLabelTrigger_FieldPathValue interface {
	LogCndSpecQueryLabelTrigger_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **LogCndSpec_Query_LabelTrigger)
	CompareWith(*LogCndSpec_Query_LabelTrigger) (cmp int, comparable bool)
}

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

func MustParseLogCndSpecQueryLabelTrigger_FieldPathValue(pathStr, valueStr string) LogCndSpecQueryLabelTrigger_FieldPathValue {
	fpv, err := ParseLogCndSpecQueryLabelTrigger_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type LogCndSpecQueryLabelTrigger_FieldTerminalPathValue struct {
	LogCndSpecQueryLabelTrigger_FieldTerminalPath
	value interface{}
}

var _ LogCndSpecQueryLabelTrigger_FieldPathValue = (*LogCndSpecQueryLabelTrigger_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'LabelTrigger' as interface{}
func (fpv *LogCndSpecQueryLabelTrigger_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *LogCndSpecQueryLabelTrigger_FieldTerminalPathValue) AsKeyValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *LogCndSpecQueryLabelTrigger_FieldTerminalPathValue) AsValuesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object LabelTrigger
func (fpv *LogCndSpecQueryLabelTrigger_FieldTerminalPathValue) SetTo(target **LogCndSpec_Query_LabelTrigger) {
	if *target == nil {
		*target = new(LogCndSpec_Query_LabelTrigger)
	}
	switch fpv.selector {
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorKey:
		(*target).Key = fpv.value.(string)
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorValues:
		(*target).Values = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_LabelTrigger: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'LogCndSpecQueryLabelTrigger_FieldTerminalPathValue' with the value under path in 'LogCndSpec_Query_LabelTrigger'.
func (fpv *LogCndSpecQueryLabelTrigger_FieldTerminalPathValue) CompareWith(source *LogCndSpec_Query_LabelTrigger) (int, bool) {
	switch fpv.selector {
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorKey:
		leftValue := fpv.value.(string)
		rightValue := source.GetKey()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorValues:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_LabelTrigger: %d", fpv.selector))
	}
}

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

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

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

func MustParseLogCndSpecQueryLabelTrigger_FieldPathArrayItemValue(pathStr, valueStr string) LogCndSpecQueryLabelTrigger_FieldPathArrayItemValue {
	fpaiv, err := ParseLogCndSpecQueryLabelTrigger_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayItemValue struct {
	LogCndSpecQueryLabelTrigger_FieldTerminalPath
	value interface{}
}

var _ LogCndSpecQueryLabelTrigger_FieldPathArrayItemValue = (*LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayItemValue) GetSingle(source *LogCndSpec_Query_LabelTrigger) (interface{}, bool) {
	return nil, false
}

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

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

// LogCndSpecQueryLabelTrigger_FieldPathArrayOfValues allows storing slice of values for LabelTrigger fields according to their type
type LogCndSpecQueryLabelTrigger_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	LogCndSpecQueryLabelTrigger_FieldPath
}

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

func MustParseLogCndSpecQueryLabelTrigger_FieldPathArrayOfValues(pathStr, valuesStr string) LogCndSpecQueryLabelTrigger_FieldPathArrayOfValues {
	fpaov, err := ParseLogCndSpecQueryLabelTrigger_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayOfValues struct {
	LogCndSpecQueryLabelTrigger_FieldTerminalPath
	values interface{}
}

var _ LogCndSpecQueryLabelTrigger_FieldPathArrayOfValues = (*LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorKey:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case LogCndSpecQueryLabelTrigger_FieldPathSelectorValues:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayOfValues) AsKeyArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *LogCndSpecQueryLabelTrigger_FieldTerminalPathArrayOfValues) AsValuesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}

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

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

type LogCndSpecQueryStringPayloadTrigger_FieldPathSelector int32

const (
	LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector LogCndSpecQueryStringPayloadTrigger_FieldPathSelector = 0
	LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex          LogCndSpecQueryStringPayloadTrigger_FieldPathSelector = 1
)

func (s LogCndSpecQueryStringPayloadTrigger_FieldPathSelector) String() string {
	switch s {
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector:
		return "object_selector"
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex:
		return "regex"
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_StringPayloadTrigger: %d", s))
	}
}

func BuildLogCndSpecQueryStringPayloadTrigger_FieldPath(fp gotenobject.RawFieldPath) (LogCndSpecQueryStringPayloadTrigger_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object LogCndSpec_Query_StringPayloadTrigger")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "object_selector", "objectSelector", "object-selector":
			return &LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath{selector: LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector}, nil
		case "regex":
			return &LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath{selector: LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object LogCndSpec_Query_StringPayloadTrigger", fp)
}

func ParseLogCndSpecQueryStringPayloadTrigger_FieldPath(rawField string) (LogCndSpecQueryStringPayloadTrigger_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildLogCndSpecQueryStringPayloadTrigger_FieldPath(fp)
}

func MustParseLogCndSpecQueryStringPayloadTrigger_FieldPath(rawField string) LogCndSpecQueryStringPayloadTrigger_FieldPath {
	fp, err := ParseLogCndSpecQueryStringPayloadTrigger_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath struct {
	selector LogCndSpecQueryStringPayloadTrigger_FieldPathSelector
}

var _ LogCndSpecQueryStringPayloadTrigger_FieldPath = (*LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath)(nil)

func (fp *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath) Selector() LogCndSpecQueryStringPayloadTrigger_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source LogCndSpec_Query_StringPayloadTrigger
func (fp *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath) GetSingle(source *LogCndSpec_Query_StringPayloadTrigger) (interface{}, bool) {
	switch fp.selector {
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector:
		return source.GetObjectSelector(), source != nil
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex:
		return source.GetRegex(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_StringPayloadTrigger: %d", fp.selector))
	}
}

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

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

func (fp *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath) ClearValue(item *LogCndSpec_Query_StringPayloadTrigger) {
	if item != nil {
		switch fp.selector {
		case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector:
			item.ObjectSelector = ""
		case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex:
			item.Regex = ""
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_StringPayloadTrigger: %d", fp.selector))
		}
	}
}

func (fp *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*LogCndSpec_Query_StringPayloadTrigger))
}

// IsLeaf - whether field path is holds simple value
func (fp *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector ||
		fp.selector == LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex
}

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

func (fp *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath) WithIValue(value interface{}) LogCndSpecQueryStringPayloadTrigger_FieldPathValue {
	switch fp.selector {
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector:
		return &LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue{LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath: *fp, value: value.(string)}
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex:
		return &LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue{LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_StringPayloadTrigger: %d", fp.selector))
	}
}

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

func (fp *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath) WithIArrayOfValues(values interface{}) LogCndSpecQueryStringPayloadTrigger_FieldPathArrayOfValues {
	fpaov := &LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayOfValues{LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath: *fp}
	switch fp.selector {
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector:
		return &LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayOfValues{LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath: *fp, values: values.([]string)}
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex:
		return &LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayOfValues{LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_StringPayloadTrigger: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// LogCndSpecQueryStringPayloadTrigger_FieldPathValue allows storing values for StringPayloadTrigger fields according to their type
type LogCndSpecQueryStringPayloadTrigger_FieldPathValue interface {
	LogCndSpecQueryStringPayloadTrigger_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **LogCndSpec_Query_StringPayloadTrigger)
	CompareWith(*LogCndSpec_Query_StringPayloadTrigger) (cmp int, comparable bool)
}

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

func MustParseLogCndSpecQueryStringPayloadTrigger_FieldPathValue(pathStr, valueStr string) LogCndSpecQueryStringPayloadTrigger_FieldPathValue {
	fpv, err := ParseLogCndSpecQueryStringPayloadTrigger_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue struct {
	LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath
	value interface{}
}

var _ LogCndSpecQueryStringPayloadTrigger_FieldPathValue = (*LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'StringPayloadTrigger' as interface{}
func (fpv *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue) AsObjectSelectorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue) AsRegexValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object StringPayloadTrigger
func (fpv *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue) SetTo(target **LogCndSpec_Query_StringPayloadTrigger) {
	if *target == nil {
		*target = new(LogCndSpec_Query_StringPayloadTrigger)
	}
	switch fpv.selector {
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector:
		(*target).ObjectSelector = fpv.value.(string)
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex:
		(*target).Regex = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_StringPayloadTrigger: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue' with the value under path in 'LogCndSpec_Query_StringPayloadTrigger'.
func (fpv *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathValue) CompareWith(source *LogCndSpec_Query_StringPayloadTrigger) (int, bool) {
	switch fpv.selector {
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector:
		leftValue := fpv.value.(string)
		rightValue := source.GetObjectSelector()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex:
		leftValue := fpv.value.(string)
		rightValue := source.GetRegex()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_StringPayloadTrigger: %d", fpv.selector))
	}
}

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

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

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

func MustParseLogCndSpecQueryStringPayloadTrigger_FieldPathArrayItemValue(pathStr, valueStr string) LogCndSpecQueryStringPayloadTrigger_FieldPathArrayItemValue {
	fpaiv, err := ParseLogCndSpecQueryStringPayloadTrigger_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayItemValue struct {
	LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath
	value interface{}
}

var _ LogCndSpecQueryStringPayloadTrigger_FieldPathArrayItemValue = (*LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayItemValue) GetSingle(source *LogCndSpec_Query_StringPayloadTrigger) (interface{}, bool) {
	return nil, false
}

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

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

// LogCndSpecQueryStringPayloadTrigger_FieldPathArrayOfValues allows storing slice of values for StringPayloadTrigger fields according to their type
type LogCndSpecQueryStringPayloadTrigger_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	LogCndSpecQueryStringPayloadTrigger_FieldPath
}

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

func MustParseLogCndSpecQueryStringPayloadTrigger_FieldPathArrayOfValues(pathStr, valuesStr string) LogCndSpecQueryStringPayloadTrigger_FieldPathArrayOfValues {
	fpaov, err := ParseLogCndSpecQueryStringPayloadTrigger_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayOfValues struct {
	LogCndSpecQueryStringPayloadTrigger_FieldTerminalPath
	values interface{}
}

var _ LogCndSpecQueryStringPayloadTrigger_FieldPathArrayOfValues = (*LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorObjectSelector:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case LogCndSpecQueryStringPayloadTrigger_FieldPathSelectorRegex:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayOfValues) AsObjectSelectorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *LogCndSpecQueryStringPayloadTrigger_FieldTerminalPathArrayOfValues) AsRegexArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type LogCndSpecQueryCompositeTrigger_FieldPathSelector int32

const (
	LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers LogCndSpecQueryCompositeTrigger_FieldPathSelector = 0
	LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator LogCndSpecQueryCompositeTrigger_FieldPathSelector = 1
)

func (s LogCndSpecQueryCompositeTrigger_FieldPathSelector) String() string {
	switch s {
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
		return "triggers"
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator:
		return "operator"
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_CompositeTrigger: %d", s))
	}
}

func BuildLogCndSpecQueryCompositeTrigger_FieldPath(fp gotenobject.RawFieldPath) (LogCndSpecQueryCompositeTrigger_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object LogCndSpec_Query_CompositeTrigger")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "triggers":
			return &LogCndSpecQueryCompositeTrigger_FieldTerminalPath{selector: LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers}, nil
		case "operator":
			return &LogCndSpecQueryCompositeTrigger_FieldTerminalPath{selector: LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object LogCndSpec_Query_CompositeTrigger", fp)
}

func ParseLogCndSpecQueryCompositeTrigger_FieldPath(rawField string) (LogCndSpecQueryCompositeTrigger_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildLogCndSpecQueryCompositeTrigger_FieldPath(fp)
}

func MustParseLogCndSpecQueryCompositeTrigger_FieldPath(rawField string) LogCndSpecQueryCompositeTrigger_FieldPath {
	fp, err := ParseLogCndSpecQueryCompositeTrigger_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type LogCndSpecQueryCompositeTrigger_FieldTerminalPath struct {
	selector LogCndSpecQueryCompositeTrigger_FieldPathSelector
}

var _ LogCndSpecQueryCompositeTrigger_FieldPath = (*LogCndSpecQueryCompositeTrigger_FieldTerminalPath)(nil)

func (fp *LogCndSpecQueryCompositeTrigger_FieldTerminalPath) Selector() LogCndSpecQueryCompositeTrigger_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source LogCndSpec_Query_CompositeTrigger
func (fp *LogCndSpecQueryCompositeTrigger_FieldTerminalPath) Get(source *LogCndSpec_Query_CompositeTrigger) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
			for _, value := range source.GetTriggers() {
				values = append(values, value)
			}
		case LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator:
			values = append(values, source.Operator)
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_CompositeTrigger: %d", fp.selector))
		}
	}
	return
}

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

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

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

// GetDefault returns a default value of the field type
func (fp *LogCndSpecQueryCompositeTrigger_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
		return ([]*LogCndSpec_Query_TriggerCnd)(nil)
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator:
		return LogCndSpec_Query_CompositeTrigger_UNDEFINED
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_CompositeTrigger: %d", fp.selector))
	}
}

func (fp *LogCndSpecQueryCompositeTrigger_FieldTerminalPath) ClearValue(item *LogCndSpec_Query_CompositeTrigger) {
	if item != nil {
		switch fp.selector {
		case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
			item.Triggers = nil
		case LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator:
			item.Operator = LogCndSpec_Query_CompositeTrigger_UNDEFINED
		default:
			panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_CompositeTrigger: %d", fp.selector))
		}
	}
}

func (fp *LogCndSpecQueryCompositeTrigger_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*LogCndSpec_Query_CompositeTrigger))
}

// IsLeaf - whether field path is holds simple value
func (fp *LogCndSpecQueryCompositeTrigger_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers ||
		fp.selector == LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator
}

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

func (fp *LogCndSpecQueryCompositeTrigger_FieldTerminalPath) WithIValue(value interface{}) LogCndSpecQueryCompositeTrigger_FieldPathValue {
	switch fp.selector {
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
		return &LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue{LogCndSpecQueryCompositeTrigger_FieldTerminalPath: *fp, value: value.([]*LogCndSpec_Query_TriggerCnd)}
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator:
		return &LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue{LogCndSpecQueryCompositeTrigger_FieldTerminalPath: *fp, value: value.(LogCndSpec_Query_CompositeTrigger_Operator)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_CompositeTrigger: %d", fp.selector))
	}
}

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

func (fp *LogCndSpecQueryCompositeTrigger_FieldTerminalPath) WithIArrayOfValues(values interface{}) LogCndSpecQueryCompositeTrigger_FieldPathArrayOfValues {
	fpaov := &LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayOfValues{LogCndSpecQueryCompositeTrigger_FieldTerminalPath: *fp}
	switch fp.selector {
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
		return &LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayOfValues{LogCndSpecQueryCompositeTrigger_FieldTerminalPath: *fp, values: values.([][]*LogCndSpec_Query_TriggerCnd)}
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator:
		return &LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayOfValues{LogCndSpecQueryCompositeTrigger_FieldTerminalPath: *fp, values: values.([]LogCndSpec_Query_CompositeTrigger_Operator)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_CompositeTrigger: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *LogCndSpecQueryCompositeTrigger_FieldTerminalPath) WithIArrayItemValue(value interface{}) LogCndSpecQueryCompositeTrigger_FieldPathArrayItemValue {
	switch fp.selector {
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
		return &LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayItemValue{LogCndSpecQueryCompositeTrigger_FieldTerminalPath: *fp, value: value.(*LogCndSpec_Query_TriggerCnd)}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_CompositeTrigger: %d", fp.selector))
	}
}

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

// LogCndSpecQueryCompositeTrigger_FieldPathValue allows storing values for CompositeTrigger fields according to their type
type LogCndSpecQueryCompositeTrigger_FieldPathValue interface {
	LogCndSpecQueryCompositeTrigger_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **LogCndSpec_Query_CompositeTrigger)
	CompareWith(*LogCndSpec_Query_CompositeTrigger) (cmp int, comparable bool)
}

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

func MustParseLogCndSpecQueryCompositeTrigger_FieldPathValue(pathStr, valueStr string) LogCndSpecQueryCompositeTrigger_FieldPathValue {
	fpv, err := ParseLogCndSpecQueryCompositeTrigger_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue struct {
	LogCndSpecQueryCompositeTrigger_FieldTerminalPath
	value interface{}
}

var _ LogCndSpecQueryCompositeTrigger_FieldPathValue = (*LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CompositeTrigger' as interface{}
func (fpv *LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue) AsTriggersValue() ([]*LogCndSpec_Query_TriggerCnd, bool) {
	res, ok := fpv.value.([]*LogCndSpec_Query_TriggerCnd)
	return res, ok
}
func (fpv *LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue) AsOperatorValue() (LogCndSpec_Query_CompositeTrigger_Operator, bool) {
	res, ok := fpv.value.(LogCndSpec_Query_CompositeTrigger_Operator)
	return res, ok
}

// SetTo stores value for selected field for object CompositeTrigger
func (fpv *LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue) SetTo(target **LogCndSpec_Query_CompositeTrigger) {
	if *target == nil {
		*target = new(LogCndSpec_Query_CompositeTrigger)
	}
	switch fpv.selector {
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
		(*target).Triggers = fpv.value.([]*LogCndSpec_Query_TriggerCnd)
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator:
		(*target).Operator = fpv.value.(LogCndSpec_Query_CompositeTrigger_Operator)
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_CompositeTrigger: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue' with the value under path in 'LogCndSpec_Query_CompositeTrigger'.
func (fpv *LogCndSpecQueryCompositeTrigger_FieldTerminalPathValue) CompareWith(source *LogCndSpec_Query_CompositeTrigger) (int, bool) {
	switch fpv.selector {
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
		return 0, false
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator:
		leftValue := fpv.value.(LogCndSpec_Query_CompositeTrigger_Operator)
		rightValue := source.GetOperator()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for LogCndSpec_Query_CompositeTrigger: %d", fpv.selector))
	}
}

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

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

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

func MustParseLogCndSpecQueryCompositeTrigger_FieldPathArrayItemValue(pathStr, valueStr string) LogCndSpecQueryCompositeTrigger_FieldPathArrayItemValue {
	fpaiv, err := ParseLogCndSpecQueryCompositeTrigger_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayItemValue struct {
	LogCndSpecQueryCompositeTrigger_FieldTerminalPath
	value interface{}
}

var _ LogCndSpecQueryCompositeTrigger_FieldPathArrayItemValue = (*LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object LogCndSpec_Query_CompositeTrigger as interface{}
func (fpaiv *LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayItemValue) AsTriggersItemValue() (*LogCndSpec_Query_TriggerCnd, bool) {
	res, ok := fpaiv.value.(*LogCndSpec_Query_TriggerCnd)
	return res, ok
}

func (fpaiv *LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayItemValue) GetSingle(source *LogCndSpec_Query_CompositeTrigger) (interface{}, bool) {
	return nil, false
}

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

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

// LogCndSpecQueryCompositeTrigger_FieldPathArrayOfValues allows storing slice of values for CompositeTrigger fields according to their type
type LogCndSpecQueryCompositeTrigger_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	LogCndSpecQueryCompositeTrigger_FieldPath
}

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

func MustParseLogCndSpecQueryCompositeTrigger_FieldPathArrayOfValues(pathStr, valuesStr string) LogCndSpecQueryCompositeTrigger_FieldPathArrayOfValues {
	fpaov, err := ParseLogCndSpecQueryCompositeTrigger_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayOfValues struct {
	LogCndSpecQueryCompositeTrigger_FieldTerminalPath
	values interface{}
}

var _ LogCndSpecQueryCompositeTrigger_FieldPathArrayOfValues = (*LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorTriggers:
		for _, v := range fpaov.values.([][]*LogCndSpec_Query_TriggerCnd) {
			values = append(values, v)
		}
	case LogCndSpecQueryCompositeTrigger_FieldPathSelectorOperator:
		for _, v := range fpaov.values.([]LogCndSpec_Query_CompositeTrigger_Operator) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayOfValues) AsTriggersArrayOfValues() ([][]*LogCndSpec_Query_TriggerCnd, bool) {
	res, ok := fpaov.values.([][]*LogCndSpec_Query_TriggerCnd)
	return res, ok
}
func (fpaov *LogCndSpecQueryCompositeTrigger_FieldTerminalPathArrayOfValues) AsOperatorArrayOfValues() ([]LogCndSpec_Query_CompositeTrigger_Operator, bool) {
	res, ok := fpaov.values.([]LogCndSpec_Query_CompositeTrigger_Operator)
	return res, ok
}

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

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

type TsCndSpec_FieldPathSelector int32

const (
	TsCndSpec_FieldPathSelectorQueries           TsCndSpec_FieldPathSelector = 0
	TsCndSpec_FieldPathSelectorQueryGroupBy      TsCndSpec_FieldPathSelector = 1
	TsCndSpec_FieldPathSelectorThresholdAlerting TsCndSpec_FieldPathSelector = 2
	TsCndSpec_FieldPathSelectorAnomalyAlerting   TsCndSpec_FieldPathSelector = 3
)

func (s TsCndSpec_FieldPathSelector) String() string {
	switch s {
	case TsCndSpec_FieldPathSelectorQueries:
		return "queries"
	case TsCndSpec_FieldPathSelectorQueryGroupBy:
		return "query_group_by"
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		return "threshold_alerting"
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		return "anomaly_alerting"
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", s))
	}
}

func BuildTsCndSpec_FieldPath(fp gotenobject.RawFieldPath) (TsCndSpec_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsCndSpec")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "queries":
			return &TsCndSpec_FieldTerminalPath{selector: TsCndSpec_FieldPathSelectorQueries}, nil
		case "query_group_by", "queryGroupBy", "query-group-by":
			return &TsCndSpec_FieldTerminalPath{selector: TsCndSpec_FieldPathSelectorQueryGroupBy}, nil
		case "threshold_alerting", "thresholdAlerting", "threshold-alerting":
			return &TsCndSpec_FieldTerminalPath{selector: TsCndSpec_FieldPathSelectorThresholdAlerting}, nil
		case "anomaly_alerting", "anomalyAlerting", "anomaly-alerting":
			return &TsCndSpec_FieldTerminalPath{selector: TsCndSpec_FieldPathSelectorAnomalyAlerting}, nil
		}
	} else {
		switch fp[0] {
		case "queries":
			if subpath, err := BuildTsCndSpecQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsCndSpec_FieldSubPath{selector: TsCndSpec_FieldPathSelectorQueries, subPath: subpath}, nil
			}
		case "threshold_alerting", "thresholdAlerting", "threshold-alerting":
			if subpath, err := BuildTsCndSpecThresholdAlertingCfg_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsCndSpec_FieldSubPath{selector: TsCndSpec_FieldPathSelectorThresholdAlerting, subPath: subpath}, nil
			}
		case "anomaly_alerting", "anomalyAlerting", "anomaly-alerting":
			if subpath, err := BuildTsCndSpecAnomalyAlertingCfg_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsCndSpec_FieldSubPath{selector: TsCndSpec_FieldPathSelectorAnomalyAlerting, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsCndSpec", fp)
}

func ParseTsCndSpec_FieldPath(rawField string) (TsCndSpec_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsCndSpec_FieldPath(fp)
}

func MustParseTsCndSpec_FieldPath(rawField string) TsCndSpec_FieldPath {
	fp, err := ParseTsCndSpec_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsCndSpec_FieldTerminalPath struct {
	selector TsCndSpec_FieldPathSelector
}

var _ TsCndSpec_FieldPath = (*TsCndSpec_FieldTerminalPath)(nil)

func (fp *TsCndSpec_FieldTerminalPath) Selector() TsCndSpec_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsCndSpec
func (fp *TsCndSpec_FieldTerminalPath) Get(source *TsCndSpec) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsCndSpec_FieldPathSelectorQueries:
			for _, value := range source.GetQueries() {
				values = append(values, value)
			}
		case TsCndSpec_FieldPathSelectorQueryGroupBy:
			for _, value := range source.GetQueryGroupBy() {
				values = append(values, value)
			}
		case TsCndSpec_FieldPathSelectorThresholdAlerting:
			if source.ThresholdAlerting != nil {
				values = append(values, source.ThresholdAlerting)
			}
		case TsCndSpec_FieldPathSelectorAnomalyAlerting:
			for _, value := range source.GetAnomalyAlerting() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsCndSpec
func (fp *TsCndSpec_FieldTerminalPath) GetSingle(source *TsCndSpec) (interface{}, bool) {
	switch fp.selector {
	case TsCndSpec_FieldPathSelectorQueries:
		res := source.GetQueries()
		return res, res != nil
	case TsCndSpec_FieldPathSelectorQueryGroupBy:
		res := source.GetQueryGroupBy()
		return res, res != nil
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		res := source.GetThresholdAlerting()
		return res, res != nil
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		res := source.GetAnomalyAlerting()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsCndSpec_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsCndSpec_FieldPathSelectorQueries:
		return ([]*TsCndSpec_Query)(nil)
	case TsCndSpec_FieldPathSelectorQueryGroupBy:
		return ([]string)(nil)
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		return (*TsCndSpec_ThresholdAlertingCfg)(nil)
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		return ([]*TsCndSpec_AnomalyAlertingCfg)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fp.selector))
	}
}

func (fp *TsCndSpec_FieldTerminalPath) ClearValue(item *TsCndSpec) {
	if item != nil {
		switch fp.selector {
		case TsCndSpec_FieldPathSelectorQueries:
			item.Queries = nil
		case TsCndSpec_FieldPathSelectorQueryGroupBy:
			item.QueryGroupBy = nil
		case TsCndSpec_FieldPathSelectorThresholdAlerting:
			item.ThresholdAlerting = nil
		case TsCndSpec_FieldPathSelectorAnomalyAlerting:
			item.AnomalyAlerting = nil
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fp.selector))
		}
	}
}

func (fp *TsCndSpec_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsCndSpec))
}

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

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

func (fp *TsCndSpec_FieldTerminalPath) WithIValue(value interface{}) TsCndSpec_FieldPathValue {
	switch fp.selector {
	case TsCndSpec_FieldPathSelectorQueries:
		return &TsCndSpec_FieldTerminalPathValue{TsCndSpec_FieldTerminalPath: *fp, value: value.([]*TsCndSpec_Query)}
	case TsCndSpec_FieldPathSelectorQueryGroupBy:
		return &TsCndSpec_FieldTerminalPathValue{TsCndSpec_FieldTerminalPath: *fp, value: value.([]string)}
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		return &TsCndSpec_FieldTerminalPathValue{TsCndSpec_FieldTerminalPath: *fp, value: value.(*TsCndSpec_ThresholdAlertingCfg)}
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		return &TsCndSpec_FieldTerminalPathValue{TsCndSpec_FieldTerminalPath: *fp, value: value.([]*TsCndSpec_AnomalyAlertingCfg)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fp.selector))
	}
}

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

func (fp *TsCndSpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsCndSpec_FieldPathArrayOfValues {
	fpaov := &TsCndSpec_FieldTerminalPathArrayOfValues{TsCndSpec_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsCndSpec_FieldPathSelectorQueries:
		return &TsCndSpec_FieldTerminalPathArrayOfValues{TsCndSpec_FieldTerminalPath: *fp, values: values.([][]*TsCndSpec_Query)}
	case TsCndSpec_FieldPathSelectorQueryGroupBy:
		return &TsCndSpec_FieldTerminalPathArrayOfValues{TsCndSpec_FieldTerminalPath: *fp, values: values.([][]string)}
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		return &TsCndSpec_FieldTerminalPathArrayOfValues{TsCndSpec_FieldTerminalPath: *fp, values: values.([]*TsCndSpec_ThresholdAlertingCfg)}
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		return &TsCndSpec_FieldTerminalPathArrayOfValues{TsCndSpec_FieldTerminalPath: *fp, values: values.([][]*TsCndSpec_AnomalyAlertingCfg)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *TsCndSpec_FieldTerminalPath) WithIArrayItemValue(value interface{}) TsCndSpec_FieldPathArrayItemValue {
	switch fp.selector {
	case TsCndSpec_FieldPathSelectorQueries:
		return &TsCndSpec_FieldTerminalPathArrayItemValue{TsCndSpec_FieldTerminalPath: *fp, value: value.(*TsCndSpec_Query)}
	case TsCndSpec_FieldPathSelectorQueryGroupBy:
		return &TsCndSpec_FieldTerminalPathArrayItemValue{TsCndSpec_FieldTerminalPath: *fp, value: value.(string)}
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		return &TsCndSpec_FieldTerminalPathArrayItemValue{TsCndSpec_FieldTerminalPath: *fp, value: value.(*TsCndSpec_AnomalyAlertingCfg)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fp.selector))
	}
}

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

type TsCndSpec_FieldSubPath struct {
	selector TsCndSpec_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ TsCndSpec_FieldPath = (*TsCndSpec_FieldSubPath)(nil)

func (fps *TsCndSpec_FieldSubPath) Selector() TsCndSpec_FieldPathSelector {
	return fps.selector
}
func (fps *TsCndSpec_FieldSubPath) AsQueriesSubPath() (TsCndSpecQuery_FieldPath, bool) {
	res, ok := fps.subPath.(TsCndSpecQuery_FieldPath)
	return res, ok
}
func (fps *TsCndSpec_FieldSubPath) AsThresholdAlertingSubPath() (TsCndSpecThresholdAlertingCfg_FieldPath, bool) {
	res, ok := fps.subPath.(TsCndSpecThresholdAlertingCfg_FieldPath)
	return res, ok
}
func (fps *TsCndSpec_FieldSubPath) AsAnomalyAlertingSubPath() (TsCndSpecAnomalyAlertingCfg_FieldPath, bool) {
	res, ok := fps.subPath.(TsCndSpecAnomalyAlertingCfg_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source TsCndSpec
func (fps *TsCndSpec_FieldSubPath) Get(source *TsCndSpec) (values []interface{}) {
	switch fps.selector {
	case TsCndSpec_FieldPathSelectorQueries:
		for _, item := range source.GetQueries() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		values = append(values, fps.subPath.GetRaw(source.GetThresholdAlerting())...)
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		for _, item := range source.GetAnomalyAlerting() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source TsCndSpec
func (fps *TsCndSpec_FieldSubPath) GetSingle(source *TsCndSpec) (interface{}, bool) {
	switch fps.selector {
	case TsCndSpec_FieldPathSelectorQueries:
		if len(source.GetQueries()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetQueries()[0])
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		if source.GetThresholdAlerting() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetThresholdAlerting())
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		if len(source.GetAnomalyAlerting()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAnomalyAlerting()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fps.selector))
	}
}

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

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

func (fps *TsCndSpec_FieldSubPath) ClearValue(item *TsCndSpec) {
	if item != nil {
		switch fps.selector {
		case TsCndSpec_FieldPathSelectorQueries:
			for _, subItem := range item.Queries {
				fps.subPath.ClearValueRaw(subItem)
			}
		case TsCndSpec_FieldPathSelectorThresholdAlerting:
			fps.subPath.ClearValueRaw(item.ThresholdAlerting)
		case TsCndSpec_FieldPathSelectorAnomalyAlerting:
			for _, subItem := range item.AnomalyAlerting {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fps.selector))
		}
	}
}

func (fps *TsCndSpec_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*TsCndSpec))
}

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

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

func (fps *TsCndSpec_FieldSubPath) WithIValue(value interface{}) TsCndSpec_FieldPathValue {
	return &TsCndSpec_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *TsCndSpec_FieldSubPath) WithIArrayOfValues(values interface{}) TsCndSpec_FieldPathArrayOfValues {
	return &TsCndSpec_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *TsCndSpec_FieldSubPath) WithIArrayItemValue(value interface{}) TsCndSpec_FieldPathArrayItemValue {
	return &TsCndSpec_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseTsCndSpec_FieldPathValue(pathStr, valueStr string) TsCndSpec_FieldPathValue {
	fpv, err := ParseTsCndSpec_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsCndSpec_FieldTerminalPathValue struct {
	TsCndSpec_FieldTerminalPath
	value interface{}
}

var _ TsCndSpec_FieldPathValue = (*TsCndSpec_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TsCndSpec' as interface{}
func (fpv *TsCndSpec_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsCndSpec_FieldTerminalPathValue) AsQueriesValue() ([]*TsCndSpec_Query, bool) {
	res, ok := fpv.value.([]*TsCndSpec_Query)
	return res, ok
}
func (fpv *TsCndSpec_FieldTerminalPathValue) AsQueryGroupByValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *TsCndSpec_FieldTerminalPathValue) AsThresholdAlertingValue() (*TsCndSpec_ThresholdAlertingCfg, bool) {
	res, ok := fpv.value.(*TsCndSpec_ThresholdAlertingCfg)
	return res, ok
}
func (fpv *TsCndSpec_FieldTerminalPathValue) AsAnomalyAlertingValue() ([]*TsCndSpec_AnomalyAlertingCfg, bool) {
	res, ok := fpv.value.([]*TsCndSpec_AnomalyAlertingCfg)
	return res, ok
}

// SetTo stores value for selected field for object TsCndSpec
func (fpv *TsCndSpec_FieldTerminalPathValue) SetTo(target **TsCndSpec) {
	if *target == nil {
		*target = new(TsCndSpec)
	}
	switch fpv.selector {
	case TsCndSpec_FieldPathSelectorQueries:
		(*target).Queries = fpv.value.([]*TsCndSpec_Query)
	case TsCndSpec_FieldPathSelectorQueryGroupBy:
		(*target).QueryGroupBy = fpv.value.([]string)
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		(*target).ThresholdAlerting = fpv.value.(*TsCndSpec_ThresholdAlertingCfg)
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		(*target).AnomalyAlerting = fpv.value.([]*TsCndSpec_AnomalyAlertingCfg)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fpv.selector))
	}
}

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

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

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

type TsCndSpec_FieldSubPathValue struct {
	TsCndSpec_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ TsCndSpec_FieldPathValue = (*TsCndSpec_FieldSubPathValue)(nil)

func (fpvs *TsCndSpec_FieldSubPathValue) AsQueriesPathValue() (TsCndSpecQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsCndSpecQuery_FieldPathValue)
	return res, ok
}
func (fpvs *TsCndSpec_FieldSubPathValue) AsThresholdAlertingPathValue() (TsCndSpecThresholdAlertingCfg_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsCndSpecThresholdAlertingCfg_FieldPathValue)
	return res, ok
}
func (fpvs *TsCndSpec_FieldSubPathValue) AsAnomalyAlertingPathValue() (TsCndSpecAnomalyAlertingCfg_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsCndSpecAnomalyAlertingCfg_FieldPathValue)
	return res, ok
}

func (fpvs *TsCndSpec_FieldSubPathValue) SetTo(target **TsCndSpec) {
	if *target == nil {
		*target = new(TsCndSpec)
	}
	switch fpvs.Selector() {
	case TsCndSpec_FieldPathSelectorQueries:
		panic("FieldPath setter is unsupported for array subpaths")
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		fpvs.subPathValue.(TsCndSpecThresholdAlertingCfg_FieldPathValue).SetTo(&(*target).ThresholdAlerting)
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *TsCndSpec_FieldSubPathValue) CompareWith(source *TsCndSpec) (int, bool) {
	switch fpvs.Selector() {
	case TsCndSpec_FieldPathSelectorQueries:
		return 0, false // repeated field
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		return fpvs.subPathValue.(TsCndSpecThresholdAlertingCfg_FieldPathValue).CompareWith(source.GetThresholdAlerting())
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseTsCndSpec_FieldPathArrayItemValue(pathStr, valueStr string) TsCndSpec_FieldPathArrayItemValue {
	fpaiv, err := ParseTsCndSpec_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsCndSpec_FieldTerminalPathArrayItemValue struct {
	TsCndSpec_FieldTerminalPath
	value interface{}
}

var _ TsCndSpec_FieldPathArrayItemValue = (*TsCndSpec_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object TsCndSpec as interface{}
func (fpaiv *TsCndSpec_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *TsCndSpec_FieldTerminalPathArrayItemValue) AsQueriesItemValue() (*TsCndSpec_Query, bool) {
	res, ok := fpaiv.value.(*TsCndSpec_Query)
	return res, ok
}
func (fpaiv *TsCndSpec_FieldTerminalPathArrayItemValue) AsQueryGroupByItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *TsCndSpec_FieldTerminalPathArrayItemValue) AsAnomalyAlertingItemValue() (*TsCndSpec_AnomalyAlertingCfg, bool) {
	res, ok := fpaiv.value.(*TsCndSpec_AnomalyAlertingCfg)
	return res, ok
}

func (fpaiv *TsCndSpec_FieldTerminalPathArrayItemValue) GetSingle(source *TsCndSpec) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *TsCndSpec_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *TsCndSpec_FieldSubPathArrayItemValue) AsQueriesPathItemValue() (TsCndSpecQuery_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(TsCndSpecQuery_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsCndSpec_FieldSubPathArrayItemValue) AsThresholdAlertingPathItemValue() (TsCndSpecThresholdAlertingCfg_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(TsCndSpecThresholdAlertingCfg_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsCndSpec_FieldSubPathArrayItemValue) AsAnomalyAlertingPathItemValue() (TsCndSpecAnomalyAlertingCfg_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(TsCndSpecAnomalyAlertingCfg_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'TsCndSpec'
func (fpaivs *TsCndSpec_FieldSubPathArrayItemValue) ContainsValue(source *TsCndSpec) bool {
	switch fpaivs.Selector() {
	case TsCndSpec_FieldPathSelectorQueries:
		return false // repeated/map field
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		return fpaivs.subPathItemValue.(TsCndSpecThresholdAlertingCfg_FieldPathArrayItemValue).ContainsValue(source.GetThresholdAlerting())
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec: %d", fpaivs.Selector()))
	}
}

// TsCndSpec_FieldPathArrayOfValues allows storing slice of values for TsCndSpec fields according to their type
type TsCndSpec_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsCndSpec_FieldPath
}

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

func MustParseTsCndSpec_FieldPathArrayOfValues(pathStr, valuesStr string) TsCndSpec_FieldPathArrayOfValues {
	fpaov, err := ParseTsCndSpec_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsCndSpec_FieldTerminalPathArrayOfValues struct {
	TsCndSpec_FieldTerminalPath
	values interface{}
}

var _ TsCndSpec_FieldPathArrayOfValues = (*TsCndSpec_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsCndSpec_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsCndSpec_FieldPathSelectorQueries:
		for _, v := range fpaov.values.([][]*TsCndSpec_Query) {
			values = append(values, v)
		}
	case TsCndSpec_FieldPathSelectorQueryGroupBy:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case TsCndSpec_FieldPathSelectorThresholdAlerting:
		for _, v := range fpaov.values.([]*TsCndSpec_ThresholdAlertingCfg) {
			values = append(values, v)
		}
	case TsCndSpec_FieldPathSelectorAnomalyAlerting:
		for _, v := range fpaov.values.([][]*TsCndSpec_AnomalyAlertingCfg) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsCndSpec_FieldTerminalPathArrayOfValues) AsQueriesArrayOfValues() ([][]*TsCndSpec_Query, bool) {
	res, ok := fpaov.values.([][]*TsCndSpec_Query)
	return res, ok
}
func (fpaov *TsCndSpec_FieldTerminalPathArrayOfValues) AsQueryGroupByArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *TsCndSpec_FieldTerminalPathArrayOfValues) AsThresholdAlertingArrayOfValues() ([]*TsCndSpec_ThresholdAlertingCfg, bool) {
	res, ok := fpaov.values.([]*TsCndSpec_ThresholdAlertingCfg)
	return res, ok
}
func (fpaov *TsCndSpec_FieldTerminalPathArrayOfValues) AsAnomalyAlertingArrayOfValues() ([][]*TsCndSpec_AnomalyAlertingCfg, bool) {
	res, ok := fpaov.values.([][]*TsCndSpec_AnomalyAlertingCfg)
	return res, ok
}

type TsCndSpec_FieldSubPathArrayOfValues struct {
	TsCndSpec_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ TsCndSpec_FieldPathArrayOfValues = (*TsCndSpec_FieldSubPathArrayOfValues)(nil)

func (fpsaov *TsCndSpec_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *TsCndSpec_FieldSubPathArrayOfValues) AsQueriesPathArrayOfValues() (TsCndSpecQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsCndSpecQuery_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsCndSpec_FieldSubPathArrayOfValues) AsThresholdAlertingPathArrayOfValues() (TsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsCndSpec_FieldSubPathArrayOfValues) AsAnomalyAlertingPathArrayOfValues() (TsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues)
	return res, ok
}

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

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

type TsCndSpecQuery_FieldPathSelector int32

const (
	TsCndSpecQuery_FieldPathSelectorName     TsCndSpecQuery_FieldPathSelector = 0
	TsCndSpecQuery_FieldPathSelectorFilter   TsCndSpecQuery_FieldPathSelector = 1
	TsCndSpecQuery_FieldPathSelectorAligner  TsCndSpecQuery_FieldPathSelector = 2
	TsCndSpecQuery_FieldPathSelectorReducer  TsCndSpecQuery_FieldPathSelector = 3
	TsCndSpecQuery_FieldPathSelectorMaxValue TsCndSpecQuery_FieldPathSelector = 4
)

func (s TsCndSpecQuery_FieldPathSelector) String() string {
	switch s {
	case TsCndSpecQuery_FieldPathSelectorName:
		return "name"
	case TsCndSpecQuery_FieldPathSelectorFilter:
		return "filter"
	case TsCndSpecQuery_FieldPathSelectorAligner:
		return "aligner"
	case TsCndSpecQuery_FieldPathSelectorReducer:
		return "reducer"
	case TsCndSpecQuery_FieldPathSelectorMaxValue:
		return "max_value"
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_Query: %d", s))
	}
}

func BuildTsCndSpecQuery_FieldPath(fp gotenobject.RawFieldPath) (TsCndSpecQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsCndSpec_Query")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &TsCndSpecQuery_FieldTerminalPath{selector: TsCndSpecQuery_FieldPathSelectorName}, nil
		case "filter":
			return &TsCndSpecQuery_FieldTerminalPath{selector: TsCndSpecQuery_FieldPathSelectorFilter}, nil
		case "aligner":
			return &TsCndSpecQuery_FieldTerminalPath{selector: TsCndSpecQuery_FieldPathSelectorAligner}, nil
		case "reducer":
			return &TsCndSpecQuery_FieldTerminalPath{selector: TsCndSpecQuery_FieldPathSelectorReducer}, nil
		case "max_value", "maxValue", "max-value":
			return &TsCndSpecQuery_FieldTerminalPath{selector: TsCndSpecQuery_FieldPathSelectorMaxValue}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsCndSpec_Query", fp)
}

func ParseTsCndSpecQuery_FieldPath(rawField string) (TsCndSpecQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsCndSpecQuery_FieldPath(fp)
}

func MustParseTsCndSpecQuery_FieldPath(rawField string) TsCndSpecQuery_FieldPath {
	fp, err := ParseTsCndSpecQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsCndSpecQuery_FieldTerminalPath struct {
	selector TsCndSpecQuery_FieldPathSelector
}

var _ TsCndSpecQuery_FieldPath = (*TsCndSpecQuery_FieldTerminalPath)(nil)

func (fp *TsCndSpecQuery_FieldTerminalPath) Selector() TsCndSpecQuery_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsCndSpec_Query
func (fp *TsCndSpecQuery_FieldTerminalPath) Get(source *TsCndSpec_Query) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsCndSpecQuery_FieldPathSelectorName:
			values = append(values, source.Name)
		case TsCndSpecQuery_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case TsCndSpecQuery_FieldPathSelectorAligner:
			values = append(values, source.Aligner)
		case TsCndSpecQuery_FieldPathSelectorReducer:
			values = append(values, source.Reducer)
		case TsCndSpecQuery_FieldPathSelectorMaxValue:
			values = append(values, source.MaxValue)
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_Query: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsCndSpec_Query
func (fp *TsCndSpecQuery_FieldTerminalPath) GetSingle(source *TsCndSpec_Query) (interface{}, bool) {
	switch fp.selector {
	case TsCndSpecQuery_FieldPathSelectorName:
		return source.GetName(), source != nil
	case TsCndSpecQuery_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case TsCndSpecQuery_FieldPathSelectorAligner:
		return source.GetAligner(), source != nil
	case TsCndSpecQuery_FieldPathSelectorReducer:
		return source.GetReducer(), source != nil
	case TsCndSpecQuery_FieldPathSelectorMaxValue:
		return source.GetMaxValue(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_Query: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsCndSpecQuery_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsCndSpecQuery_FieldPathSelectorName:
		return ""
	case TsCndSpecQuery_FieldPathSelectorFilter:
		return (*monitoring_time_serie.Filter)(nil)
	case TsCndSpecQuery_FieldPathSelectorAligner:
		return monitoring_common.Aggregation_ALIGN_NONE
	case TsCndSpecQuery_FieldPathSelectorReducer:
		return monitoring_common.Aggregation_REDUCE_NONE
	case TsCndSpecQuery_FieldPathSelectorMaxValue:
		return float64(0)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_Query: %d", fp.selector))
	}
}

func (fp *TsCndSpecQuery_FieldTerminalPath) ClearValue(item *TsCndSpec_Query) {
	if item != nil {
		switch fp.selector {
		case TsCndSpecQuery_FieldPathSelectorName:
			item.Name = ""
		case TsCndSpecQuery_FieldPathSelectorFilter:
			item.Filter = nil
		case TsCndSpecQuery_FieldPathSelectorAligner:
			item.Aligner = monitoring_common.Aggregation_ALIGN_NONE
		case TsCndSpecQuery_FieldPathSelectorReducer:
			item.Reducer = monitoring_common.Aggregation_REDUCE_NONE
		case TsCndSpecQuery_FieldPathSelectorMaxValue:
			item.MaxValue = float64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_Query: %d", fp.selector))
		}
	}
}

func (fp *TsCndSpecQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsCndSpec_Query))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsCndSpecQuery_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsCndSpecQuery_FieldPathSelectorName ||
		fp.selector == TsCndSpecQuery_FieldPathSelectorFilter ||
		fp.selector == TsCndSpecQuery_FieldPathSelectorAligner ||
		fp.selector == TsCndSpecQuery_FieldPathSelectorReducer ||
		fp.selector == TsCndSpecQuery_FieldPathSelectorMaxValue
}

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

func (fp *TsCndSpecQuery_FieldTerminalPath) WithIValue(value interface{}) TsCndSpecQuery_FieldPathValue {
	switch fp.selector {
	case TsCndSpecQuery_FieldPathSelectorName:
		return &TsCndSpecQuery_FieldTerminalPathValue{TsCndSpecQuery_FieldTerminalPath: *fp, value: value.(string)}
	case TsCndSpecQuery_FieldPathSelectorFilter:
		return &TsCndSpecQuery_FieldTerminalPathValue{TsCndSpecQuery_FieldTerminalPath: *fp, value: value.(*monitoring_time_serie.Filter)}
	case TsCndSpecQuery_FieldPathSelectorAligner:
		return &TsCndSpecQuery_FieldTerminalPathValue{TsCndSpecQuery_FieldTerminalPath: *fp, value: value.(monitoring_common.Aggregation_Aligner)}
	case TsCndSpecQuery_FieldPathSelectorReducer:
		return &TsCndSpecQuery_FieldTerminalPathValue{TsCndSpecQuery_FieldTerminalPath: *fp, value: value.(monitoring_common.Aggregation_Reducer)}
	case TsCndSpecQuery_FieldPathSelectorMaxValue:
		return &TsCndSpecQuery_FieldTerminalPathValue{TsCndSpecQuery_FieldTerminalPath: *fp, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_Query: %d", fp.selector))
	}
}

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

func (fp *TsCndSpecQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsCndSpecQuery_FieldPathArrayOfValues {
	fpaov := &TsCndSpecQuery_FieldTerminalPathArrayOfValues{TsCndSpecQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsCndSpecQuery_FieldPathSelectorName:
		return &TsCndSpecQuery_FieldTerminalPathArrayOfValues{TsCndSpecQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case TsCndSpecQuery_FieldPathSelectorFilter:
		return &TsCndSpecQuery_FieldTerminalPathArrayOfValues{TsCndSpecQuery_FieldTerminalPath: *fp, values: values.([]*monitoring_time_serie.Filter)}
	case TsCndSpecQuery_FieldPathSelectorAligner:
		return &TsCndSpecQuery_FieldTerminalPathArrayOfValues{TsCndSpecQuery_FieldTerminalPath: *fp, values: values.([]monitoring_common.Aggregation_Aligner)}
	case TsCndSpecQuery_FieldPathSelectorReducer:
		return &TsCndSpecQuery_FieldTerminalPathArrayOfValues{TsCndSpecQuery_FieldTerminalPath: *fp, values: values.([]monitoring_common.Aggregation_Reducer)}
	case TsCndSpecQuery_FieldPathSelectorMaxValue:
		return &TsCndSpecQuery_FieldTerminalPathArrayOfValues{TsCndSpecQuery_FieldTerminalPath: *fp, values: values.([]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_Query: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseTsCndSpecQuery_FieldPathValue(pathStr, valueStr string) TsCndSpecQuery_FieldPathValue {
	fpv, err := ParseTsCndSpecQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsCndSpecQuery_FieldTerminalPathValue struct {
	TsCndSpecQuery_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecQuery_FieldPathValue = (*TsCndSpecQuery_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Query' as interface{}
func (fpv *TsCndSpecQuery_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsCndSpecQuery_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *TsCndSpecQuery_FieldTerminalPathValue) AsFilterValue() (*monitoring_time_serie.Filter, bool) {
	res, ok := fpv.value.(*monitoring_time_serie.Filter)
	return res, ok
}
func (fpv *TsCndSpecQuery_FieldTerminalPathValue) AsAlignerValue() (monitoring_common.Aggregation_Aligner, bool) {
	res, ok := fpv.value.(monitoring_common.Aggregation_Aligner)
	return res, ok
}
func (fpv *TsCndSpecQuery_FieldTerminalPathValue) AsReducerValue() (monitoring_common.Aggregation_Reducer, bool) {
	res, ok := fpv.value.(monitoring_common.Aggregation_Reducer)
	return res, ok
}
func (fpv *TsCndSpecQuery_FieldTerminalPathValue) AsMaxValueValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}

// SetTo stores value for selected field for object Query
func (fpv *TsCndSpecQuery_FieldTerminalPathValue) SetTo(target **TsCndSpec_Query) {
	if *target == nil {
		*target = new(TsCndSpec_Query)
	}
	switch fpv.selector {
	case TsCndSpecQuery_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case TsCndSpecQuery_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*monitoring_time_serie.Filter)
	case TsCndSpecQuery_FieldPathSelectorAligner:
		(*target).Aligner = fpv.value.(monitoring_common.Aggregation_Aligner)
	case TsCndSpecQuery_FieldPathSelectorReducer:
		(*target).Reducer = fpv.value.(monitoring_common.Aggregation_Reducer)
	case TsCndSpecQuery_FieldPathSelectorMaxValue:
		(*target).MaxValue = fpv.value.(float64)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_Query: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'TsCndSpecQuery_FieldTerminalPathValue' with the value under path in 'TsCndSpec_Query'.
func (fpv *TsCndSpecQuery_FieldTerminalPathValue) CompareWith(source *TsCndSpec_Query) (int, bool) {
	switch fpv.selector {
	case TsCndSpecQuery_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecQuery_FieldPathSelectorFilter:
		return 0, false
	case TsCndSpecQuery_FieldPathSelectorAligner:
		leftValue := fpv.value.(monitoring_common.Aggregation_Aligner)
		rightValue := source.GetAligner()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecQuery_FieldPathSelectorReducer:
		leftValue := fpv.value.(monitoring_common.Aggregation_Reducer)
		rightValue := source.GetReducer()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecQuery_FieldPathSelectorMaxValue:
		leftValue := fpv.value.(float64)
		rightValue := source.GetMaxValue()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_Query: %d", fpv.selector))
	}
}

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

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

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

func MustParseTsCndSpecQuery_FieldPathArrayItemValue(pathStr, valueStr string) TsCndSpecQuery_FieldPathArrayItemValue {
	fpaiv, err := ParseTsCndSpecQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsCndSpecQuery_FieldTerminalPathArrayItemValue struct {
	TsCndSpecQuery_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecQuery_FieldPathArrayItemValue = (*TsCndSpecQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *TsCndSpecQuery_FieldTerminalPathArrayItemValue) GetSingle(source *TsCndSpec_Query) (interface{}, bool) {
	return nil, false
}

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

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

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

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

func MustParseTsCndSpecQuery_FieldPathArrayOfValues(pathStr, valuesStr string) TsCndSpecQuery_FieldPathArrayOfValues {
	fpaov, err := ParseTsCndSpecQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsCndSpecQuery_FieldTerminalPathArrayOfValues struct {
	TsCndSpecQuery_FieldTerminalPath
	values interface{}
}

var _ TsCndSpecQuery_FieldPathArrayOfValues = (*TsCndSpecQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsCndSpecQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsCndSpecQuery_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case TsCndSpecQuery_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*monitoring_time_serie.Filter) {
			values = append(values, v)
		}
	case TsCndSpecQuery_FieldPathSelectorAligner:
		for _, v := range fpaov.values.([]monitoring_common.Aggregation_Aligner) {
			values = append(values, v)
		}
	case TsCndSpecQuery_FieldPathSelectorReducer:
		for _, v := range fpaov.values.([]monitoring_common.Aggregation_Reducer) {
			values = append(values, v)
		}
	case TsCndSpecQuery_FieldPathSelectorMaxValue:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsCndSpecQuery_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *TsCndSpecQuery_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*monitoring_time_serie.Filter, bool) {
	res, ok := fpaov.values.([]*monitoring_time_serie.Filter)
	return res, ok
}
func (fpaov *TsCndSpecQuery_FieldTerminalPathArrayOfValues) AsAlignerArrayOfValues() ([]monitoring_common.Aggregation_Aligner, bool) {
	res, ok := fpaov.values.([]monitoring_common.Aggregation_Aligner)
	return res, ok
}
func (fpaov *TsCndSpecQuery_FieldTerminalPathArrayOfValues) AsReducerArrayOfValues() ([]monitoring_common.Aggregation_Reducer, bool) {
	res, ok := fpaov.values.([]monitoring_common.Aggregation_Reducer)
	return res, ok
}
func (fpaov *TsCndSpecQuery_FieldTerminalPathArrayOfValues) AsMaxValueArrayOfValues() ([]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 TsCndSpecThresholdAlertingCfg_FieldPath interface {
	gotenobject.FieldPath
	Selector() TsCndSpecThresholdAlertingCfg_FieldPathSelector
	Get(source *TsCndSpec_ThresholdAlertingCfg) []interface{}
	GetSingle(source *TsCndSpec_ThresholdAlertingCfg) (interface{}, bool)
	ClearValue(item *TsCndSpec_ThresholdAlertingCfg)

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

type TsCndSpecThresholdAlertingCfg_FieldPathSelector int32

const (
	TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator                          TsCndSpecThresholdAlertingCfg_FieldPathSelector = 0
	TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod                   TsCndSpecThresholdAlertingCfg_FieldPathSelector = 1
	TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter                        TsCndSpecThresholdAlertingCfg_FieldPathSelector = 2
	TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter                      TsCndSpecThresholdAlertingCfg_FieldPathSelector = 3
	TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds                TsCndSpecThresholdAlertingCfg_FieldPathSelector = 4
	TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod TsCndSpecThresholdAlertingCfg_FieldPathSelector = 5
)

func (s TsCndSpecThresholdAlertingCfg_FieldPathSelector) String() string {
	switch s {
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
		return "operator"
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
		return "alignment_period"
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
		return "raise_after"
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
		return "silence_after"
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
		return "per_query_thresholds"
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
		return "adaptive_thresholds_detection_period"
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg: %d", s))
	}
}

func BuildTsCndSpecThresholdAlertingCfg_FieldPath(fp gotenobject.RawFieldPath) (TsCndSpecThresholdAlertingCfg_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsCndSpec_ThresholdAlertingCfg")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "operator":
			return &TsCndSpecThresholdAlertingCfg_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator}, nil
		case "alignment_period", "alignmentPeriod", "alignment-period":
			return &TsCndSpecThresholdAlertingCfg_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod}, nil
		case "raise_after", "raiseAfter", "raise-after":
			return &TsCndSpecThresholdAlertingCfg_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter}, nil
		case "silence_after", "silenceAfter", "silence-after":
			return &TsCndSpecThresholdAlertingCfg_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter}, nil
		case "per_query_thresholds", "perQueryThresholds", "per-query-thresholds":
			return &TsCndSpecThresholdAlertingCfg_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds}, nil
		case "adaptive_thresholds_detection_period", "adaptiveThresholdsDetectionPeriod", "adaptive-thresholds-detection-period":
			return &TsCndSpecThresholdAlertingCfg_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod}, nil
		}
	} else {
		switch fp[0] {
		case "per_query_thresholds", "perQueryThresholds", "per-query-thresholds":
			if subpath, err := BuildTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsCndSpecThresholdAlertingCfg_FieldSubPath{selector: TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsCndSpec_ThresholdAlertingCfg", fp)
}

func ParseTsCndSpecThresholdAlertingCfg_FieldPath(rawField string) (TsCndSpecThresholdAlertingCfg_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsCndSpecThresholdAlertingCfg_FieldPath(fp)
}

func MustParseTsCndSpecThresholdAlertingCfg_FieldPath(rawField string) TsCndSpecThresholdAlertingCfg_FieldPath {
	fp, err := ParseTsCndSpecThresholdAlertingCfg_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsCndSpecThresholdAlertingCfg_FieldTerminalPath struct {
	selector TsCndSpecThresholdAlertingCfg_FieldPathSelector
}

var _ TsCndSpecThresholdAlertingCfg_FieldPath = (*TsCndSpecThresholdAlertingCfg_FieldTerminalPath)(nil)

func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) Selector() TsCndSpecThresholdAlertingCfg_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsCndSpec_ThresholdAlertingCfg
func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) Get(source *TsCndSpec_ThresholdAlertingCfg) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
			values = append(values, source.Operator)
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
			if source.AlignmentPeriod != nil {
				values = append(values, source.AlignmentPeriod)
			}
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
			if source.RaiseAfter != nil {
				values = append(values, source.RaiseAfter)
			}
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
			if source.SilenceAfter != nil {
				values = append(values, source.SilenceAfter)
			}
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
			for _, value := range source.GetPerQueryThresholds() {
				values = append(values, value)
			}
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
			if source.AdaptiveThresholdsDetectionPeriod != nil {
				values = append(values, source.AdaptiveThresholdsDetectionPeriod)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsCndSpec_ThresholdAlertingCfg
func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) GetSingle(source *TsCndSpec_ThresholdAlertingCfg) (interface{}, bool) {
	switch fp.selector {
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
		return source.GetOperator(), source != nil
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
		res := source.GetAlignmentPeriod()
		return res, res != nil
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
		res := source.GetRaiseAfter()
		return res, res != nil
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
		res := source.GetSilenceAfter()
		return res, res != nil
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
		res := source.GetPerQueryThresholds()
		return res, res != nil
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
		res := source.GetAdaptiveThresholdsDetectionPeriod()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
		return TsCndSpec_ThresholdAlertingCfg_UNDEFINED
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
		return (*durationpb.Duration)(nil)
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
		return (*durationpb.Duration)(nil)
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
		return (*durationpb.Duration)(nil)
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
		return ([]*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)(nil)
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
		return (*durationpb.Duration)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg: %d", fp.selector))
	}
}

func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) ClearValue(item *TsCndSpec_ThresholdAlertingCfg) {
	if item != nil {
		switch fp.selector {
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
			item.Operator = TsCndSpec_ThresholdAlertingCfg_UNDEFINED
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
			item.AlignmentPeriod = nil
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
			item.RaiseAfter = nil
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
			item.SilenceAfter = nil
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
			item.PerQueryThresholds = nil
		case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
			item.AdaptiveThresholdsDetectionPeriod = nil
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg: %d", fp.selector))
		}
	}
}

func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsCndSpec_ThresholdAlertingCfg))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator ||
		fp.selector == TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod ||
		fp.selector == TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter ||
		fp.selector == TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter ||
		fp.selector == TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod
}

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

func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) WithIValue(value interface{}) TsCndSpecThresholdAlertingCfg_FieldPathValue {
	switch fp.selector {
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, value: value.(TsCndSpec_ThresholdAlertingCfg_Operator)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, value: value.([]*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg: %d", fp.selector))
	}
}

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

func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues {
	fpaov := &TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, values: values.([]TsCndSpec_ThresholdAlertingCfg_Operator)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, values: values.([][]*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *TsCndSpecThresholdAlertingCfg_FieldTerminalPath) WithIArrayItemValue(value interface{}) TsCndSpecThresholdAlertingCfg_FieldPathArrayItemValue {
	switch fp.selector {
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
		return &TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayItemValue{TsCndSpecThresholdAlertingCfg_FieldTerminalPath: *fp, value: value.(*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg: %d", fp.selector))
	}
}

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

type TsCndSpecThresholdAlertingCfg_FieldSubPath struct {
	selector TsCndSpecThresholdAlertingCfg_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ TsCndSpecThresholdAlertingCfg_FieldPath = (*TsCndSpecThresholdAlertingCfg_FieldSubPath)(nil)

func (fps *TsCndSpecThresholdAlertingCfg_FieldSubPath) Selector() TsCndSpecThresholdAlertingCfg_FieldPathSelector {
	return fps.selector
}
func (fps *TsCndSpecThresholdAlertingCfg_FieldSubPath) AsPerQueryThresholdsSubPath() (TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath, bool) {
	res, ok := fps.subPath.(TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *TsCndSpecThresholdAlertingCfg_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*TsCndSpec_ThresholdAlertingCfg))
}

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

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

func (fps *TsCndSpecThresholdAlertingCfg_FieldSubPath) WithIValue(value interface{}) TsCndSpecThresholdAlertingCfg_FieldPathValue {
	return &TsCndSpecThresholdAlertingCfg_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *TsCndSpecThresholdAlertingCfg_FieldSubPath) WithIArrayOfValues(values interface{}) TsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues {
	return &TsCndSpecThresholdAlertingCfg_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *TsCndSpecThresholdAlertingCfg_FieldSubPath) WithIArrayItemValue(value interface{}) TsCndSpecThresholdAlertingCfg_FieldPathArrayItemValue {
	return &TsCndSpecThresholdAlertingCfg_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// TsCndSpecThresholdAlertingCfg_FieldPathValue allows storing values for ThresholdAlertingCfg fields according to their type
type TsCndSpecThresholdAlertingCfg_FieldPathValue interface {
	TsCndSpecThresholdAlertingCfg_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsCndSpec_ThresholdAlertingCfg)
	CompareWith(*TsCndSpec_ThresholdAlertingCfg) (cmp int, comparable bool)
}

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

func MustParseTsCndSpecThresholdAlertingCfg_FieldPathValue(pathStr, valueStr string) TsCndSpecThresholdAlertingCfg_FieldPathValue {
	fpv, err := ParseTsCndSpecThresholdAlertingCfg_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue struct {
	TsCndSpecThresholdAlertingCfg_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecThresholdAlertingCfg_FieldPathValue = (*TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ThresholdAlertingCfg' as interface{}
func (fpv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue) AsOperatorValue() (TsCndSpec_ThresholdAlertingCfg_Operator, bool) {
	res, ok := fpv.value.(TsCndSpec_ThresholdAlertingCfg_Operator)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue) AsAlignmentPeriodValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue) AsRaiseAfterValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue) AsSilenceAfterValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue) AsPerQueryThresholdsValue() ([]*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds, bool) {
	res, ok := fpv.value.([]*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue) AsAdaptiveThresholdsDetectionPeriodValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}

// SetTo stores value for selected field for object ThresholdAlertingCfg
func (fpv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue) SetTo(target **TsCndSpec_ThresholdAlertingCfg) {
	if *target == nil {
		*target = new(TsCndSpec_ThresholdAlertingCfg)
	}
	switch fpv.selector {
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
		(*target).Operator = fpv.value.(TsCndSpec_ThresholdAlertingCfg_Operator)
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
		(*target).AlignmentPeriod = fpv.value.(*durationpb.Duration)
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
		(*target).RaiseAfter = fpv.value.(*durationpb.Duration)
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
		(*target).SilenceAfter = fpv.value.(*durationpb.Duration)
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
		(*target).PerQueryThresholds = fpv.value.([]*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
		(*target).AdaptiveThresholdsDetectionPeriod = fpv.value.(*durationpb.Duration)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue' with the value under path in 'TsCndSpec_ThresholdAlertingCfg'.
func (fpv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathValue) CompareWith(source *TsCndSpec_ThresholdAlertingCfg) (int, bool) {
	switch fpv.selector {
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
		leftValue := fpv.value.(TsCndSpec_ThresholdAlertingCfg_Operator)
		rightValue := source.GetOperator()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetAlignmentPeriod()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetRaiseAfter()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetSilenceAfter()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
		return 0, false
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetAdaptiveThresholdsDetectionPeriod()
		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 TsCndSpec_ThresholdAlertingCfg: %d", fpv.selector))
	}
}

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

type TsCndSpecThresholdAlertingCfg_FieldSubPathValue struct {
	TsCndSpecThresholdAlertingCfg_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ TsCndSpecThresholdAlertingCfg_FieldPathValue = (*TsCndSpecThresholdAlertingCfg_FieldSubPathValue)(nil)

func (fpvs *TsCndSpecThresholdAlertingCfg_FieldSubPathValue) AsPerQueryThresholdsPathValue() (TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseTsCndSpecThresholdAlertingCfg_FieldPathArrayItemValue(pathStr, valueStr string) TsCndSpecThresholdAlertingCfg_FieldPathArrayItemValue {
	fpaiv, err := ParseTsCndSpecThresholdAlertingCfg_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayItemValue struct {
	TsCndSpecThresholdAlertingCfg_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecThresholdAlertingCfg_FieldPathArrayItemValue = (*TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object TsCndSpec_ThresholdAlertingCfg as interface{}
func (fpaiv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayItemValue) AsPerQueryThresholdsItemValue() (*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds, bool) {
	res, ok := fpaiv.value.(*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)
	return res, ok
}

func (fpaiv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayItemValue) GetSingle(source *TsCndSpec_ThresholdAlertingCfg) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ThresholdAlertingCfg'
func (fpaiv *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayItemValue) ContainsValue(source *TsCndSpec_ThresholdAlertingCfg) bool {
	slice := fpaiv.TsCndSpecThresholdAlertingCfg_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 TsCndSpecThresholdAlertingCfg_FieldSubPathArrayItemValue struct {
	TsCndSpecThresholdAlertingCfg_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// TsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues allows storing slice of values for ThresholdAlertingCfg fields according to their type
type TsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsCndSpecThresholdAlertingCfg_FieldPath
}

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

func MustParseTsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues(pathStr, valuesStr string) TsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues {
	fpaov, err := ParseTsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues struct {
	TsCndSpecThresholdAlertingCfg_FieldTerminalPath
	values interface{}
}

var _ TsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues = (*TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorOperator:
		for _, v := range fpaov.values.([]TsCndSpec_ThresholdAlertingCfg_Operator) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAlignmentPeriod:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorRaiseAfter:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorSilenceAfter:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorPerQueryThresholds:
		for _, v := range fpaov.values.([][]*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfg_FieldPathSelectorAdaptiveThresholdsDetectionPeriod:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues) AsOperatorArrayOfValues() ([]TsCndSpec_ThresholdAlertingCfg_Operator, bool) {
	res, ok := fpaov.values.([]TsCndSpec_ThresholdAlertingCfg_Operator)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues) AsAlignmentPeriodArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues) AsRaiseAfterArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues) AsSilenceAfterArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues) AsPerQueryThresholdsArrayOfValues() ([][]*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds, bool) {
	res, ok := fpaov.values.([][]*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfg_FieldTerminalPathArrayOfValues) AsAdaptiveThresholdsDetectionPeriodArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}

type TsCndSpecThresholdAlertingCfg_FieldSubPathArrayOfValues struct {
	TsCndSpecThresholdAlertingCfg_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ TsCndSpecThresholdAlertingCfg_FieldPathArrayOfValues = (*TsCndSpecThresholdAlertingCfg_FieldSubPathArrayOfValues)(nil)

func (fpsaov *TsCndSpecThresholdAlertingCfg_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *TsCndSpecThresholdAlertingCfg_FieldSubPathArrayOfValues) AsPerQueryThresholdsPathArrayOfValues() (TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues)
	return res, ok
}

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

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

type TsCndSpecAnomalyAlertingCfg_FieldPathSelector int32

const (
	TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow    TsCndSpecAnomalyAlertingCfg_FieldPathSelector = 0
	TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval      TsCndSpecAnomalyAlertingCfg_FieldPathSelector = 1
	TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval TsCndSpecAnomalyAlertingCfg_FieldPathSelector = 2
	TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod   TsCndSpecAnomalyAlertingCfg_FieldPathSelector = 3
	TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder   TsCndSpecAnomalyAlertingCfg_FieldPathSelector = 4
	TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter        TsCndSpecAnomalyAlertingCfg_FieldPathSelector = 5
	TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter      TsCndSpecAnomalyAlertingCfg_FieldPathSelector = 6
)

func (s TsCndSpecAnomalyAlertingCfg_FieldPathSelector) String() string {
	switch s {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
		return "analysis_window"
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
		return "step_interval"
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
		return "train_step_interval"
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
		return "alignment_period"
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		return "lstm_autoencoder"
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
		return "raise_after"
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
		return "silence_after"
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", s))
	}
}

func BuildTsCndSpecAnomalyAlertingCfg_FieldPath(fp gotenobject.RawFieldPath) (TsCndSpecAnomalyAlertingCfg_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsCndSpec_AnomalyAlertingCfg")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "analysis_window", "analysisWindow", "analysis-window":
			return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow}, nil
		case "step_interval", "stepInterval", "step-interval":
			return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval}, nil
		case "train_step_interval", "trainStepInterval", "train-step-interval":
			return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval}, nil
		case "alignment_period", "alignmentPeriod", "alignment-period":
			return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod}, nil
		case "lstm_autoencoder", "lstmAutoencoder", "lstm-autoencoder":
			return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder}, nil
		case "raise_after", "raiseAfter", "raise-after":
			return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter}, nil
		case "silence_after", "silenceAfter", "silence-after":
			return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter}, nil
		}
	} else {
		switch fp[0] {
		case "lstm_autoencoder", "lstmAutoencoder", "lstm-autoencoder":
			if subpath, err := BuildTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsCndSpecAnomalyAlertingCfg_FieldSubPath{selector: TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsCndSpec_AnomalyAlertingCfg", fp)
}

func ParseTsCndSpecAnomalyAlertingCfg_FieldPath(rawField string) (TsCndSpecAnomalyAlertingCfg_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsCndSpecAnomalyAlertingCfg_FieldPath(fp)
}

func MustParseTsCndSpecAnomalyAlertingCfg_FieldPath(rawField string) TsCndSpecAnomalyAlertingCfg_FieldPath {
	fp, err := ParseTsCndSpecAnomalyAlertingCfg_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsCndSpecAnomalyAlertingCfg_FieldTerminalPath struct {
	selector TsCndSpecAnomalyAlertingCfg_FieldPathSelector
}

var _ TsCndSpecAnomalyAlertingCfg_FieldPath = (*TsCndSpecAnomalyAlertingCfg_FieldTerminalPath)(nil)

func (fp *TsCndSpecAnomalyAlertingCfg_FieldTerminalPath) Selector() TsCndSpecAnomalyAlertingCfg_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsCndSpec_AnomalyAlertingCfg
func (fp *TsCndSpecAnomalyAlertingCfg_FieldTerminalPath) Get(source *TsCndSpec_AnomalyAlertingCfg) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
			if source.AnalysisWindow != nil {
				values = append(values, source.AnalysisWindow)
			}
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
			if source.StepInterval != nil {
				values = append(values, source.StepInterval)
			}
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
			if source.TrainStepInterval != nil {
				values = append(values, source.TrainStepInterval)
			}
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
			if source.AlignmentPeriod != nil {
				values = append(values, source.AlignmentPeriod)
			}
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
			if source, ok := source.Model.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder); ok && source != nil {
				if source.LstmAutoencoder != nil {
					values = append(values, source.LstmAutoencoder)
				}
			}
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
			if source.RaiseAfter != nil {
				values = append(values, source.RaiseAfter)
			}
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
			if source.SilenceAfter != nil {
				values = append(values, source.SilenceAfter)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsCndSpec_AnomalyAlertingCfg
func (fp *TsCndSpecAnomalyAlertingCfg_FieldTerminalPath) GetSingle(source *TsCndSpec_AnomalyAlertingCfg) (interface{}, bool) {
	switch fp.selector {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
		res := source.GetAnalysisWindow()
		return res, res != nil
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
		res := source.GetStepInterval()
		return res, res != nil
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
		res := source.GetTrainStepInterval()
		return res, res != nil
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
		res := source.GetAlignmentPeriod()
		return res, res != nil
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetLstmAutoencoder(), false
		}
		_, oneOfSelected := source.Model.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder)
		if !oneOfSelected {
			return source.GetLstmAutoencoder(), false // to return "type" information
		}
		res := source.GetLstmAutoencoder()
		return res, res != nil
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
		res := source.GetRaiseAfter()
		return res, res != nil
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
		res := source.GetSilenceAfter()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsCndSpecAnomalyAlertingCfg_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
		return (*durationpb.Duration)(nil)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
		return (*durationpb.Duration)(nil)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
		return (*durationpb.Duration)(nil)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
		return (*durationpb.Duration)(nil)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		return (*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder)(nil)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
		return (*durationpb.Duration)(nil)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
		return (*durationpb.Duration)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fp.selector))
	}
}

func (fp *TsCndSpecAnomalyAlertingCfg_FieldTerminalPath) ClearValue(item *TsCndSpec_AnomalyAlertingCfg) {
	if item != nil {
		switch fp.selector {
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
			item.AnalysisWindow = nil
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
			item.StepInterval = nil
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
			item.TrainStepInterval = nil
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
			item.AlignmentPeriod = nil
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
			if item, ok := item.Model.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder); ok {
				item.LstmAutoencoder = nil
			}
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
			item.RaiseAfter = nil
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
			item.SilenceAfter = nil
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fp.selector))
		}
	}
}

func (fp *TsCndSpecAnomalyAlertingCfg_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsCndSpec_AnomalyAlertingCfg))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsCndSpecAnomalyAlertingCfg_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow ||
		fp.selector == TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval ||
		fp.selector == TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval ||
		fp.selector == TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod ||
		fp.selector == TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter ||
		fp.selector == TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter
}

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

func (fp *TsCndSpecAnomalyAlertingCfg_FieldTerminalPath) WithIValue(value interface{}) TsCndSpecAnomalyAlertingCfg_FieldPathValue {
	switch fp.selector {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, value: value.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fp.selector))
	}
}

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

func (fp *TsCndSpecAnomalyAlertingCfg_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues {
	fpaov := &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, values: values.([]*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
		return &TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfg_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type TsCndSpecAnomalyAlertingCfg_FieldSubPath struct {
	selector TsCndSpecAnomalyAlertingCfg_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ TsCndSpecAnomalyAlertingCfg_FieldPath = (*TsCndSpecAnomalyAlertingCfg_FieldSubPath)(nil)

func (fps *TsCndSpecAnomalyAlertingCfg_FieldSubPath) Selector() TsCndSpecAnomalyAlertingCfg_FieldPathSelector {
	return fps.selector
}
func (fps *TsCndSpecAnomalyAlertingCfg_FieldSubPath) AsLstmAutoencoderSubPath() (TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath, bool) {
	res, ok := fps.subPath.(TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *TsCndSpecAnomalyAlertingCfg_FieldSubPath) ClearValue(item *TsCndSpec_AnomalyAlertingCfg) {
	if item != nil {
		switch fps.selector {
		case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
			if item.Model != nil {
				if item, ok := item.Model.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder); ok {
					fps.subPath.ClearValueRaw(item.LstmAutoencoder)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fps.selector))
		}
	}
}

func (fps *TsCndSpecAnomalyAlertingCfg_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*TsCndSpec_AnomalyAlertingCfg))
}

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

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

func (fps *TsCndSpecAnomalyAlertingCfg_FieldSubPath) WithIValue(value interface{}) TsCndSpecAnomalyAlertingCfg_FieldPathValue {
	return &TsCndSpecAnomalyAlertingCfg_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *TsCndSpecAnomalyAlertingCfg_FieldSubPath) WithIArrayOfValues(values interface{}) TsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues {
	return &TsCndSpecAnomalyAlertingCfg_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *TsCndSpecAnomalyAlertingCfg_FieldSubPath) WithIArrayItemValue(value interface{}) TsCndSpecAnomalyAlertingCfg_FieldPathArrayItemValue {
	return &TsCndSpecAnomalyAlertingCfg_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// TsCndSpecAnomalyAlertingCfg_FieldPathValue allows storing values for AnomalyAlertingCfg fields according to their type
type TsCndSpecAnomalyAlertingCfg_FieldPathValue interface {
	TsCndSpecAnomalyAlertingCfg_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsCndSpec_AnomalyAlertingCfg)
	CompareWith(*TsCndSpec_AnomalyAlertingCfg) (cmp int, comparable bool)
}

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

func MustParseTsCndSpecAnomalyAlertingCfg_FieldPathValue(pathStr, valueStr string) TsCndSpecAnomalyAlertingCfg_FieldPathValue {
	fpv, err := ParseTsCndSpecAnomalyAlertingCfg_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue struct {
	TsCndSpecAnomalyAlertingCfg_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecAnomalyAlertingCfg_FieldPathValue = (*TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AnomalyAlertingCfg' as interface{}
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) AsAnalysisWindowValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) AsStepIntervalValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) AsTrainStepIntervalValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) AsAlignmentPeriodValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) AsLstmAutoencoderValue() (*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder, bool) {
	res, ok := fpv.value.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) AsRaiseAfterValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) AsSilenceAfterValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}

// SetTo stores value for selected field for object AnomalyAlertingCfg
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) SetTo(target **TsCndSpec_AnomalyAlertingCfg) {
	if *target == nil {
		*target = new(TsCndSpec_AnomalyAlertingCfg)
	}
	switch fpv.selector {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
		(*target).AnalysisWindow = fpv.value.(*durationpb.Duration)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
		(*target).StepInterval = fpv.value.(*durationpb.Duration)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
		(*target).TrainStepInterval = fpv.value.(*durationpb.Duration)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
		(*target).AlignmentPeriod = fpv.value.(*durationpb.Duration)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		if _, ok := (*target).Model.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder); !ok {
			(*target).Model = &TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder{}
		}
		(*target).Model.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder).LstmAutoencoder = fpv.value.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
		(*target).RaiseAfter = fpv.value.(*durationpb.Duration)
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
		(*target).SilenceAfter = fpv.value.(*durationpb.Duration)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue' with the value under path in 'TsCndSpec_AnomalyAlertingCfg'.
func (fpv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathValue) CompareWith(source *TsCndSpec_AnomalyAlertingCfg) (int, bool) {
	switch fpv.selector {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetAnalysisWindow()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetStepInterval()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetTrainStepInterval()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetAlignmentPeriod()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		return 0, false
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetRaiseAfter()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetSilenceAfter()
		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 TsCndSpec_AnomalyAlertingCfg: %d", fpv.selector))
	}
}

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

type TsCndSpecAnomalyAlertingCfg_FieldSubPathValue struct {
	TsCndSpecAnomalyAlertingCfg_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ TsCndSpecAnomalyAlertingCfg_FieldPathValue = (*TsCndSpecAnomalyAlertingCfg_FieldSubPathValue)(nil)

func (fpvs *TsCndSpecAnomalyAlertingCfg_FieldSubPathValue) AsLstmAutoencoderPathValue() (TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue)
	return res, ok
}

func (fpvs *TsCndSpecAnomalyAlertingCfg_FieldSubPathValue) SetTo(target **TsCndSpec_AnomalyAlertingCfg) {
	if *target == nil {
		*target = new(TsCndSpec_AnomalyAlertingCfg)
	}
	switch fpvs.Selector() {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		if _, ok := (*target).Model.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder); !ok {
			(*target).Model = &TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder{}
		}
		fpvs.subPathValue.(TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue).SetTo(&(*target).Model.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoencoder).LstmAutoencoder)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *TsCndSpecAnomalyAlertingCfg_FieldSubPathValue) CompareWith(source *TsCndSpec_AnomalyAlertingCfg) (int, bool) {
	switch fpvs.Selector() {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		return fpvs.subPathValue.(TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue).CompareWith(source.GetLstmAutoencoder())
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseTsCndSpecAnomalyAlertingCfg_FieldPathArrayItemValue(pathStr, valueStr string) TsCndSpecAnomalyAlertingCfg_FieldPathArrayItemValue {
	fpaiv, err := ParseTsCndSpecAnomalyAlertingCfg_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayItemValue struct {
	TsCndSpecAnomalyAlertingCfg_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecAnomalyAlertingCfg_FieldPathArrayItemValue = (*TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayItemValue) GetSingle(source *TsCndSpec_AnomalyAlertingCfg) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'AnomalyAlertingCfg'
func (fpaiv *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayItemValue) ContainsValue(source *TsCndSpec_AnomalyAlertingCfg) bool {
	slice := fpaiv.TsCndSpecAnomalyAlertingCfg_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 TsCndSpecAnomalyAlertingCfg_FieldSubPathArrayItemValue struct {
	TsCndSpecAnomalyAlertingCfg_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'AnomalyAlertingCfg'
func (fpaivs *TsCndSpecAnomalyAlertingCfg_FieldSubPathArrayItemValue) ContainsValue(source *TsCndSpec_AnomalyAlertingCfg) bool {
	switch fpaivs.Selector() {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		return fpaivs.subPathItemValue.(TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayItemValue).ContainsValue(source.GetLstmAutoencoder())
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg: %d", fpaivs.Selector()))
	}
}

// TsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues allows storing slice of values for AnomalyAlertingCfg fields according to their type
type TsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsCndSpecAnomalyAlertingCfg_FieldPath
}

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

func MustParseTsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues(pathStr, valuesStr string) TsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues {
	fpaov, err := ParseTsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues struct {
	TsCndSpecAnomalyAlertingCfg_FieldTerminalPath
	values interface{}
}

var _ TsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues = (*TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAnalysisWindow:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorStepInterval:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorTrainStepInterval:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorAlignmentPeriod:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorLstmAutoencoder:
		for _, v := range fpaov.values.([]*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorRaiseAfter:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfg_FieldPathSelectorSilenceAfter:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues) AsAnalysisWindowArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues) AsStepIntervalArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues) AsTrainStepIntervalArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues) AsAlignmentPeriodArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues) AsLstmAutoencoderArrayOfValues() ([]*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder, bool) {
	res, ok := fpaov.values.([]*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues) AsRaiseAfterArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfg_FieldTerminalPathArrayOfValues) AsSilenceAfterArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}

type TsCndSpecAnomalyAlertingCfg_FieldSubPathArrayOfValues struct {
	TsCndSpecAnomalyAlertingCfg_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ TsCndSpecAnomalyAlertingCfg_FieldPathArrayOfValues = (*TsCndSpecAnomalyAlertingCfg_FieldSubPathArrayOfValues)(nil)

func (fpsaov *TsCndSpecAnomalyAlertingCfg_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *TsCndSpecAnomalyAlertingCfg_FieldSubPathArrayOfValues) AsLstmAutoencoderPathArrayOfValues() (TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayOfValues)
	return res, ok
}

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

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

type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector int32

const (
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector = 0
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector = 1
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper       TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector = 2
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower       TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector = 3
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper       TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector = 4
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower       TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector = 5
)

func (s TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector) String() string {
	switch s {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
		return "auto_adapt_upper"
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
		return "auto_adapt_lower"
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		return "max_upper"
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		return "max_lower"
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		return "min_upper"
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		return "min_lower"
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", s))
	}
}

func BuildTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath(fp gotenobject.RawFieldPath) (TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsCndSpec_ThresholdAlertingCfg_AlertingThresholds")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "auto_adapt_upper", "autoAdaptUpper", "auto-adapt-upper":
			return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper}, nil
		case "auto_adapt_lower", "autoAdaptLower", "auto-adapt-lower":
			return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower}, nil
		case "max_upper", "maxUpper", "max-upper":
			return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper}, nil
		case "max_lower", "maxLower", "max-lower":
			return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower}, nil
		case "min_upper", "minUpper", "min-upper":
			return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper}, nil
		case "min_lower", "minLower", "min-lower":
			return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower}, nil
		}
	} else {
		switch fp[0] {
		case "max_upper", "maxUpper", "max-upper":
			if subpath, err := BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper, subPath: subpath}, nil
			}
		case "max_lower", "maxLower", "max-lower":
			if subpath, err := BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower, subPath: subpath}, nil
			}
		case "min_upper", "minUpper", "min-upper":
			if subpath, err := BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper, subPath: subpath}, nil
			}
		case "min_lower", "minLower", "min-lower":
			if subpath, err := BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath{selector: TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsCndSpec_ThresholdAlertingCfg_AlertingThresholds", fp)
}

func ParseTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath(rawField string) (TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath(fp)
}

func MustParseTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath(rawField string) TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath {
	fp, err := ParseTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath struct {
	selector TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector
}

var _ TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath = (*TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath)(nil)

func (fp *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath) Selector() TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsCndSpec_ThresholdAlertingCfg_AlertingThresholds
func (fp *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath) Get(source *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
			values = append(values, source.AutoAdaptUpper)
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
			values = append(values, source.AutoAdaptLower)
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
			if source.MaxUpper != nil {
				values = append(values, source.MaxUpper)
			}
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
			if source.MaxLower != nil {
				values = append(values, source.MaxLower)
			}
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
			if source.MinUpper != nil {
				values = append(values, source.MinUpper)
			}
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
			if source.MinLower != nil {
				values = append(values, source.MinLower)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsCndSpec_ThresholdAlertingCfg_AlertingThresholds
func (fp *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath) GetSingle(source *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) (interface{}, bool) {
	switch fp.selector {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
		return source.GetAutoAdaptUpper(), source != nil
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
		return source.GetAutoAdaptLower(), source != nil
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		res := source.GetMaxUpper()
		return res, res != nil
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		res := source.GetMaxLower()
		return res, res != nil
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		res := source.GetMinUpper()
		return res, res != nil
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		res := source.GetMinLower()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
		return false
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
		return false
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		return (*AlertingThreshold)(nil)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		return (*AlertingThreshold)(nil)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		return (*AlertingThreshold)(nil)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		return (*AlertingThreshold)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fp.selector))
	}
}

func (fp *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath) ClearValue(item *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) {
	if item != nil {
		switch fp.selector {
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
			item.AutoAdaptUpper = false
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
			item.AutoAdaptLower = false
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
			item.MaxUpper = nil
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
			item.MaxLower = nil
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
			item.MinUpper = nil
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
			item.MinLower = nil
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fp.selector))
		}
	}
}

func (fp *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper ||
		fp.selector == TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower
}

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

func (fp *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath) WithIValue(value interface{}) TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue {
	switch fp.selector {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, value: value.(bool)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, value: value.(bool)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, value: value.(*AlertingThreshold)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, value: value.(*AlertingThreshold)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, value: value.(*AlertingThreshold)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, value: value.(*AlertingThreshold)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fp.selector))
	}
}

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

func (fp *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues {
	fpaov := &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, values: values.([]bool)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, values: values.([]bool)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, values: values.([]*AlertingThreshold)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, values: values.([]*AlertingThreshold)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, values: values.([]*AlertingThreshold)}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues{TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath: *fp, values: values.([]*AlertingThreshold)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath struct {
	selector TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath = (*TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath)(nil)

func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) Selector() TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelector {
	return fps.selector
}
func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) AsMaxUpperSubPath() (AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingThreshold_FieldPath)
	return res, ok
}
func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) AsMaxLowerSubPath() (AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingThreshold_FieldPath)
	return res, ok
}
func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) AsMinUpperSubPath() (AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingThreshold_FieldPath)
	return res, ok
}
func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) AsMinLowerSubPath() (AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingThreshold_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source TsCndSpec_ThresholdAlertingCfg_AlertingThresholds
func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) Get(source *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) (values []interface{}) {
	switch fps.selector {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		values = append(values, fps.subPath.GetRaw(source.GetMaxUpper())...)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		values = append(values, fps.subPath.GetRaw(source.GetMaxLower())...)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		values = append(values, fps.subPath.GetRaw(source.GetMinUpper())...)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		values = append(values, fps.subPath.GetRaw(source.GetMinLower())...)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source TsCndSpec_ThresholdAlertingCfg_AlertingThresholds
func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) GetSingle(source *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) (interface{}, bool) {
	switch fps.selector {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		if source.GetMaxUpper() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMaxUpper())
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		if source.GetMaxLower() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMaxLower())
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		if source.GetMinUpper() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMinUpper())
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		if source.GetMinLower() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMinLower())
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fps.selector))
	}
}

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

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

func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) ClearValue(item *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) {
	if item != nil {
		switch fps.selector {
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
			fps.subPath.ClearValueRaw(item.MaxUpper)
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
			fps.subPath.ClearValueRaw(item.MaxLower)
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
			fps.subPath.ClearValueRaw(item.MinUpper)
		case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
			fps.subPath.ClearValueRaw(item.MinLower)
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fps.selector))
		}
	}
}

func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds))
}

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

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

func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) WithIValue(value interface{}) TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue {
	return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) WithIArrayOfValues(values interface{}) TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues {
	return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPath) WithIArrayItemValue(value interface{}) TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayItemValue {
	return &TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue allows storing values for AlertingThresholds fields according to their type
type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue interface {
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)
	CompareWith(*TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) (cmp int, comparable bool)
}

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

func MustParseTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue(pathStr, valueStr string) TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue {
	fpv, err := ParseTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue struct {
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue = (*TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AlertingThresholds' as interface{}
func (fpv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue) AsAutoAdaptUpperValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue) AsAutoAdaptLowerValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue) AsMaxUpperValue() (*AlertingThreshold, bool) {
	res, ok := fpv.value.(*AlertingThreshold)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue) AsMaxLowerValue() (*AlertingThreshold, bool) {
	res, ok := fpv.value.(*AlertingThreshold)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue) AsMinUpperValue() (*AlertingThreshold, bool) {
	res, ok := fpv.value.(*AlertingThreshold)
	return res, ok
}
func (fpv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue) AsMinLowerValue() (*AlertingThreshold, bool) {
	res, ok := fpv.value.(*AlertingThreshold)
	return res, ok
}

// SetTo stores value for selected field for object AlertingThresholds
func (fpv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue) SetTo(target **TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) {
	if *target == nil {
		*target = new(TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)
	}
	switch fpv.selector {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
		(*target).AutoAdaptUpper = fpv.value.(bool)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
		(*target).AutoAdaptLower = fpv.value.(bool)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		(*target).MaxUpper = fpv.value.(*AlertingThreshold)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		(*target).MaxLower = fpv.value.(*AlertingThreshold)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		(*target).MinUpper = fpv.value.(*AlertingThreshold)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		(*target).MinLower = fpv.value.(*AlertingThreshold)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue' with the value under path in 'TsCndSpec_ThresholdAlertingCfg_AlertingThresholds'.
func (fpv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathValue) CompareWith(source *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) (int, bool) {
	switch fpv.selector {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
		leftValue := fpv.value.(bool)
		rightValue := source.GetAutoAdaptUpper()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
		leftValue := fpv.value.(bool)
		rightValue := source.GetAutoAdaptLower()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		return 0, false
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		return 0, false
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		return 0, false
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fpv.selector))
	}
}

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

type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathValue struct {
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathValue = (*TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathValue)(nil)

func (fpvs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathValue) AsMaxUpperPathValue() (AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingThreshold_FieldPathValue)
	return res, ok
}
func (fpvs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathValue) AsMaxLowerPathValue() (AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingThreshold_FieldPathValue)
	return res, ok
}
func (fpvs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathValue) AsMinUpperPathValue() (AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingThreshold_FieldPathValue)
	return res, ok
}
func (fpvs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathValue) AsMinLowerPathValue() (AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingThreshold_FieldPathValue)
	return res, ok
}

func (fpvs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathValue) SetTo(target **TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) {
	if *target == nil {
		*target = new(TsCndSpec_ThresholdAlertingCfg_AlertingThresholds)
	}
	switch fpvs.Selector() {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		fpvs.subPathValue.(AlertingThreshold_FieldPathValue).SetTo(&(*target).MaxUpper)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		fpvs.subPathValue.(AlertingThreshold_FieldPathValue).SetTo(&(*target).MaxLower)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		fpvs.subPathValue.(AlertingThreshold_FieldPathValue).SetTo(&(*target).MinUpper)
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		fpvs.subPathValue.(AlertingThreshold_FieldPathValue).SetTo(&(*target).MinLower)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathValue) CompareWith(source *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) (int, bool) {
	switch fpvs.Selector() {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		return fpvs.subPathValue.(AlertingThreshold_FieldPathValue).CompareWith(source.GetMaxUpper())
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		return fpvs.subPathValue.(AlertingThreshold_FieldPathValue).CompareWith(source.GetMaxLower())
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		return fpvs.subPathValue.(AlertingThreshold_FieldPathValue).CompareWith(source.GetMinUpper())
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		return fpvs.subPathValue.(AlertingThreshold_FieldPathValue).CompareWith(source.GetMinLower())
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayItemValue(pathStr, valueStr string) TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayItemValue {
	fpaiv, err := ParseTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayItemValue struct {
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayItemValue = (*TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayItemValue) GetSingle(source *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'AlertingThresholds'
func (fpaiv *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayItemValue) ContainsValue(source *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) bool {
	slice := fpaiv.TsCndSpecThresholdAlertingCfgAlertingThresholds_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 TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayItemValue struct {
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayItemValue) AsMaxUpperPathItemValue() (AlertingThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertingThreshold_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayItemValue) AsMaxLowerPathItemValue() (AlertingThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertingThreshold_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayItemValue) AsMinUpperPathItemValue() (AlertingThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertingThreshold_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayItemValue) AsMinLowerPathItemValue() (AlertingThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertingThreshold_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'AlertingThresholds'
func (fpaivs *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayItemValue) ContainsValue(source *TsCndSpec_ThresholdAlertingCfg_AlertingThresholds) bool {
	switch fpaivs.Selector() {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		return fpaivs.subPathItemValue.(AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetMaxUpper())
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		return fpaivs.subPathItemValue.(AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetMaxLower())
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		return fpaivs.subPathItemValue.(AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetMinUpper())
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		return fpaivs.subPathItemValue.(AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetMinLower())
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_ThresholdAlertingCfg_AlertingThresholds: %d", fpaivs.Selector()))
	}
}

// TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues allows storing slice of values for AlertingThresholds fields according to their type
type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath
}

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

func MustParseTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues(pathStr, valuesStr string) TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues {
	fpaov, err := ParseTsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues struct {
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPath
	values interface{}
}

var _ TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues = (*TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptUpper:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorAutoAdaptLower:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxUpper:
		for _, v := range fpaov.values.([]*AlertingThreshold) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMaxLower:
		for _, v := range fpaov.values.([]*AlertingThreshold) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinUpper:
		for _, v := range fpaov.values.([]*AlertingThreshold) {
			values = append(values, v)
		}
	case TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathSelectorMinLower:
		for _, v := range fpaov.values.([]*AlertingThreshold) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues) AsAutoAdaptUpperArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues) AsAutoAdaptLowerArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues) AsMaxUpperArrayOfValues() ([]*AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*AlertingThreshold)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues) AsMaxLowerArrayOfValues() ([]*AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*AlertingThreshold)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues) AsMinUpperArrayOfValues() ([]*AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*AlertingThreshold)
	return res, ok
}
func (fpaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldTerminalPathArrayOfValues) AsMinLowerArrayOfValues() ([]*AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*AlertingThreshold)
	return res, ok
}

type TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayOfValues struct {
	TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldPathArrayOfValues = (*TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayOfValues)(nil)

func (fpsaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayOfValues) AsMaxUpperPathArrayOfValues() (AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayOfValues) AsMaxLowerPathArrayOfValues() (AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayOfValues) AsMinUpperPathArrayOfValues() (AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsCndSpecThresholdAlertingCfgAlertingThresholds_FieldSubPathArrayOfValues) AsMinLowerPathArrayOfValues() (AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}

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

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

type TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector int32

const (
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize              TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector = 0
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate               TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector = 1
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs       TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector = 2
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs       TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector = 3
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector = 4
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod          TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector = 5
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction     TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector = 6
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector = 7
)

func (s TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector) String() string {
	switch s {
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
		return "hidden_size"
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
		return "learn_rate"
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
		return "max_training_epochs"
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
		return "min_training_epochs"
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
		return "acceptable_training_error"
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
		return "training_period"
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
		return "check_period_fraction"
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
		return "teacher_force_at_inference"
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder: %d", s))
	}
}

func BuildTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath(fp gotenobject.RawFieldPath) (TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "hidden_size", "hiddenSize", "hidden-size":
			return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize}, nil
		case "learn_rate", "learnRate", "learn-rate":
			return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate}, nil
		case "max_training_epochs", "maxTrainingEpochs", "max-training-epochs":
			return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs}, nil
		case "min_training_epochs", "minTrainingEpochs", "min-training-epochs":
			return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs}, nil
		case "acceptable_training_error", "acceptableTrainingError", "acceptable-training-error":
			return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError}, nil
		case "training_period", "trainingPeriod", "training-period":
			return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod}, nil
		case "check_period_fraction", "checkPeriodFraction", "check-period-fraction":
			return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction}, nil
		case "teacher_force_at_inference", "teacherForceAtInference", "teacher-force-at-inference":
			return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath{selector: TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder", fp)
}

func ParseTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath(rawField string) (TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath(fp)
}

func MustParseTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath(rawField string) TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath {
	fp, err := ParseTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath struct {
	selector TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector
}

var _ TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath = (*TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath)(nil)

func (fp *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath) Selector() TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder
func (fp *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath) Get(source *TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
			values = append(values, source.HiddenSize)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
			values = append(values, source.LearnRate)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
			values = append(values, source.MaxTrainingEpochs)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
			values = append(values, source.MinTrainingEpochs)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
			values = append(values, source.AcceptableTrainingError)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
			if source.TrainingPeriod != nil {
				values = append(values, source.TrainingPeriod)
			}
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
			values = append(values, source.CheckPeriodFraction)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
			values = append(values, source.TeacherForceAtInference)
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder
func (fp *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath) GetSingle(source *TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder) (interface{}, bool) {
	switch fp.selector {
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
		return source.GetHiddenSize(), source != nil
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
		return source.GetLearnRate(), source != nil
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
		return source.GetMaxTrainingEpochs(), source != nil
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
		return source.GetMinTrainingEpochs(), source != nil
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
		return source.GetAcceptableTrainingError(), source != nil
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
		res := source.GetTrainingPeriod()
		return res, res != nil
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
		return source.GetCheckPeriodFraction(), source != nil
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
		return source.GetTeacherForceAtInference(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
		return int32(0)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
		return float64(0)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
		return int32(0)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
		return int32(0)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
		return float64(0)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
		return (*durationpb.Duration)(nil)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
		return float64(0)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder: %d", fp.selector))
	}
}

func (fp *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath) ClearValue(item *TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder) {
	if item != nil {
		switch fp.selector {
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
			item.HiddenSize = int32(0)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
			item.LearnRate = float64(0)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
			item.MaxTrainingEpochs = int32(0)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
			item.MinTrainingEpochs = int32(0)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
			item.AcceptableTrainingError = float64(0)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
			item.TrainingPeriod = nil
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
			item.CheckPeriodFraction = float64(0)
		case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
			item.TeacherForceAtInference = false
		default:
			panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder: %d", fp.selector))
		}
	}
}

func (fp *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize ||
		fp.selector == TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate ||
		fp.selector == TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs ||
		fp.selector == TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs ||
		fp.selector == TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError ||
		fp.selector == TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod ||
		fp.selector == TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction ||
		fp.selector == TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference
}

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

func (fp *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath) WithIValue(value interface{}) TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue {
	switch fp.selector {
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, value: value.(int32)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, value: value.(float64)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, value: value.(int32)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, value: value.(int32)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, value: value.(float64)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, value: value.(float64)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder: %d", fp.selector))
	}
}

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

func (fp *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayOfValues {
	fpaov := &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, values: values.([]int32)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, values: values.([]float64)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, values: values.([]int32)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, values: values.([]int32)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, values: values.([]float64)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, values: values.([]float64)}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
		return &TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues{TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue allows storing values for LstmAutoEncoder fields according to their type
type TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue interface {
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder)
	CompareWith(*TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder) (cmp int, comparable bool)
}

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

func MustParseTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue(pathStr, valueStr string) TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue {
	fpv, err := ParseTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue struct {
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathValue = (*TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'LstmAutoEncoder' as interface{}
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) AsHiddenSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) AsLearnRateValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) AsMaxTrainingEpochsValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) AsMinTrainingEpochsValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) AsAcceptableTrainingErrorValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) AsTrainingPeriodValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) AsCheckPeriodFractionValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) AsTeacherForceAtInferenceValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object LstmAutoEncoder
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) SetTo(target **TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder) {
	if *target == nil {
		*target = new(TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder)
	}
	switch fpv.selector {
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
		(*target).HiddenSize = fpv.value.(int32)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
		(*target).LearnRate = fpv.value.(float64)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
		(*target).MaxTrainingEpochs = fpv.value.(int32)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
		(*target).MinTrainingEpochs = fpv.value.(int32)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
		(*target).AcceptableTrainingError = fpv.value.(float64)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
		(*target).TrainingPeriod = fpv.value.(*durationpb.Duration)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
		(*target).CheckPeriodFraction = fpv.value.(float64)
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
		(*target).TeacherForceAtInference = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue' with the value under path in 'TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder'.
func (fpv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathValue) CompareWith(source *TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder) (int, bool) {
	switch fpv.selector {
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetHiddenSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
		leftValue := fpv.value.(float64)
		rightValue := source.GetLearnRate()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
		leftValue := fpv.value.(int32)
		rightValue := source.GetMaxTrainingEpochs()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
		leftValue := fpv.value.(int32)
		rightValue := source.GetMinTrainingEpochs()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
		leftValue := fpv.value.(float64)
		rightValue := source.GetAcceptableTrainingError()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetTrainingPeriod()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
		leftValue := fpv.value.(float64)
		rightValue := source.GetCheckPeriodFraction()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
		leftValue := fpv.value.(bool)
		rightValue := source.GetTeacherForceAtInference()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder: %d", fpv.selector))
	}
}

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

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

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

func MustParseTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayItemValue(pathStr, valueStr string) TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayItemValue {
	fpaiv, err := ParseTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayItemValue struct {
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath
	value interface{}
}

var _ TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayItemValue = (*TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayItemValue) GetSingle(source *TsCndSpec_AnomalyAlertingCfg_LstmAutoEncoder) (interface{}, bool) {
	return nil, false
}

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

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

// TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayOfValues allows storing slice of values for LstmAutoEncoder fields according to their type
type TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPath
}

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

func MustParseTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayOfValues(pathStr, valuesStr string) TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayOfValues {
	fpaov, err := ParseTsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues struct {
	TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPath
	values interface{}
}

var _ TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathArrayOfValues = (*TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorHiddenSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorLearnRate:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMaxTrainingEpochs:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorMinTrainingEpochs:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorAcceptableTrainingError:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTrainingPeriod:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorCheckPeriodFraction:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	case TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldPathSelectorTeacherForceAtInference:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues) AsHiddenSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues) AsLearnRateArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues) AsMaxTrainingEpochsArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues) AsMinTrainingEpochsArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues) AsAcceptableTrainingErrorArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues) AsTrainingPeriodArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues) AsCheckPeriodFractionArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}
func (fpaov *TsCndSpecAnomalyAlertingCfgLstmAutoEncoder_FieldTerminalPathArrayOfValues) AsTeacherForceAtInferenceArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

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

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

type PolicySpec_FieldPathSelector int32

const (
	PolicySpec_FieldPathSelectorEnabled            PolicySpec_FieldPathSelector = 0
	PolicySpec_FieldPathSelectorProcessingLocation PolicySpec_FieldPathSelector = 1
	PolicySpec_FieldPathSelectorResourceIdentity   PolicySpec_FieldPathSelector = 2
	PolicySpec_FieldPathSelectorSupportingQueries  PolicySpec_FieldPathSelector = 3
	PolicySpec_FieldPathSelectorAiAgent            PolicySpec_FieldPathSelector = 4
)

func (s PolicySpec_FieldPathSelector) String() string {
	switch s {
	case PolicySpec_FieldPathSelectorEnabled:
		return "enabled"
	case PolicySpec_FieldPathSelectorProcessingLocation:
		return "processing_location"
	case PolicySpec_FieldPathSelectorResourceIdentity:
		return "resource_identity"
	case PolicySpec_FieldPathSelectorSupportingQueries:
		return "supporting_queries"
	case PolicySpec_FieldPathSelectorAiAgent:
		return "ai_agent"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", s))
	}
}

func BuildPolicySpec_FieldPath(fp gotenobject.RawFieldPath) (PolicySpec_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "enabled":
			return &PolicySpec_FieldTerminalPath{selector: PolicySpec_FieldPathSelectorEnabled}, nil
		case "processing_location", "processingLocation", "processing-location":
			return &PolicySpec_FieldTerminalPath{selector: PolicySpec_FieldPathSelectorProcessingLocation}, nil
		case "resource_identity", "resourceIdentity", "resource-identity":
			return &PolicySpec_FieldTerminalPath{selector: PolicySpec_FieldPathSelectorResourceIdentity}, nil
		case "supporting_queries", "supportingQueries", "supporting-queries":
			return &PolicySpec_FieldTerminalPath{selector: PolicySpec_FieldPathSelectorSupportingQueries}, nil
		case "ai_agent", "aiAgent", "ai-agent":
			return &PolicySpec_FieldTerminalPath{selector: PolicySpec_FieldPathSelectorAiAgent}, nil
		}
	} else {
		switch fp[0] {
		case "resource_identity", "resourceIdentity", "resource-identity":
			if subpath, err := BuildPolicySpecResourceIdentity_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpec_FieldSubPath{selector: PolicySpec_FieldPathSelectorResourceIdentity, subPath: subpath}, nil
			}
		case "supporting_queries", "supportingQueries", "supporting-queries":
			if subpath, err := BuildPolicySpecSupportingAlertQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpec_FieldSubPath{selector: PolicySpec_FieldPathSelectorSupportingQueries, subPath: subpath}, nil
			}
		case "ai_agent", "aiAgent", "ai-agent":
			if subpath, err := BuildPolicySpecAIAgentHandling_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpec_FieldSubPath{selector: PolicySpec_FieldPathSelectorAiAgent, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec", fp)
}

func ParsePolicySpec_FieldPath(rawField string) (PolicySpec_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpec_FieldPath(fp)
}

func MustParsePolicySpec_FieldPath(rawField string) PolicySpec_FieldPath {
	fp, err := ParsePolicySpec_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpec_FieldTerminalPath struct {
	selector PolicySpec_FieldPathSelector
}

var _ PolicySpec_FieldPath = (*PolicySpec_FieldTerminalPath)(nil)

func (fp *PolicySpec_FieldTerminalPath) Selector() PolicySpec_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec
func (fp *PolicySpec_FieldTerminalPath) Get(source *PolicySpec) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpec_FieldPathSelectorEnabled:
			values = append(values, source.Enabled)
		case PolicySpec_FieldPathSelectorProcessingLocation:
			values = append(values, source.ProcessingLocation)
		case PolicySpec_FieldPathSelectorResourceIdentity:
			if source.ResourceIdentity != nil {
				values = append(values, source.ResourceIdentity)
			}
		case PolicySpec_FieldPathSelectorSupportingQueries:
			for _, value := range source.GetSupportingQueries() {
				values = append(values, value)
			}
		case PolicySpec_FieldPathSelectorAiAgent:
			if source.AiAgent != nil {
				values = append(values, source.AiAgent)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec
func (fp *PolicySpec_FieldTerminalPath) GetSingle(source *PolicySpec) (interface{}, bool) {
	switch fp.selector {
	case PolicySpec_FieldPathSelectorEnabled:
		return source.GetEnabled(), source != nil
	case PolicySpec_FieldPathSelectorProcessingLocation:
		return source.GetProcessingLocation(), source != nil
	case PolicySpec_FieldPathSelectorResourceIdentity:
		res := source.GetResourceIdentity()
		return res, res != nil
	case PolicySpec_FieldPathSelectorSupportingQueries:
		res := source.GetSupportingQueries()
		return res, res != nil
	case PolicySpec_FieldPathSelectorAiAgent:
		res := source.GetAiAgent()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpec_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpec_FieldPathSelectorEnabled:
		return false
	case PolicySpec_FieldPathSelectorProcessingLocation:
		return PolicySpec_UNDEFINED
	case PolicySpec_FieldPathSelectorResourceIdentity:
		return (*PolicySpec_ResourceIdentity)(nil)
	case PolicySpec_FieldPathSelectorSupportingQueries:
		return ([]*PolicySpec_SupportingAlertQuery)(nil)
	case PolicySpec_FieldPathSelectorAiAgent:
		return (*PolicySpec_AIAgentHandling)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fp.selector))
	}
}

func (fp *PolicySpec_FieldTerminalPath) ClearValue(item *PolicySpec) {
	if item != nil {
		switch fp.selector {
		case PolicySpec_FieldPathSelectorEnabled:
			item.Enabled = false
		case PolicySpec_FieldPathSelectorProcessingLocation:
			item.ProcessingLocation = PolicySpec_UNDEFINED
		case PolicySpec_FieldPathSelectorResourceIdentity:
			item.ResourceIdentity = nil
		case PolicySpec_FieldPathSelectorSupportingQueries:
			item.SupportingQueries = nil
		case PolicySpec_FieldPathSelectorAiAgent:
			item.AiAgent = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fp.selector))
		}
	}
}

func (fp *PolicySpec_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpec_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpec_FieldPathSelectorEnabled ||
		fp.selector == PolicySpec_FieldPathSelectorProcessingLocation
}

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

func (fp *PolicySpec_FieldTerminalPath) WithIValue(value interface{}) PolicySpec_FieldPathValue {
	switch fp.selector {
	case PolicySpec_FieldPathSelectorEnabled:
		return &PolicySpec_FieldTerminalPathValue{PolicySpec_FieldTerminalPath: *fp, value: value.(bool)}
	case PolicySpec_FieldPathSelectorProcessingLocation:
		return &PolicySpec_FieldTerminalPathValue{PolicySpec_FieldTerminalPath: *fp, value: value.(PolicySpec_ProcessingLocation)}
	case PolicySpec_FieldPathSelectorResourceIdentity:
		return &PolicySpec_FieldTerminalPathValue{PolicySpec_FieldTerminalPath: *fp, value: value.(*PolicySpec_ResourceIdentity)}
	case PolicySpec_FieldPathSelectorSupportingQueries:
		return &PolicySpec_FieldTerminalPathValue{PolicySpec_FieldTerminalPath: *fp, value: value.([]*PolicySpec_SupportingAlertQuery)}
	case PolicySpec_FieldPathSelectorAiAgent:
		return &PolicySpec_FieldTerminalPathValue{PolicySpec_FieldTerminalPath: *fp, value: value.(*PolicySpec_AIAgentHandling)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fp.selector))
	}
}

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

func (fp *PolicySpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpec_FieldPathArrayOfValues {
	fpaov := &PolicySpec_FieldTerminalPathArrayOfValues{PolicySpec_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpec_FieldPathSelectorEnabled:
		return &PolicySpec_FieldTerminalPathArrayOfValues{PolicySpec_FieldTerminalPath: *fp, values: values.([]bool)}
	case PolicySpec_FieldPathSelectorProcessingLocation:
		return &PolicySpec_FieldTerminalPathArrayOfValues{PolicySpec_FieldTerminalPath: *fp, values: values.([]PolicySpec_ProcessingLocation)}
	case PolicySpec_FieldPathSelectorResourceIdentity:
		return &PolicySpec_FieldTerminalPathArrayOfValues{PolicySpec_FieldTerminalPath: *fp, values: values.([]*PolicySpec_ResourceIdentity)}
	case PolicySpec_FieldPathSelectorSupportingQueries:
		return &PolicySpec_FieldTerminalPathArrayOfValues{PolicySpec_FieldTerminalPath: *fp, values: values.([][]*PolicySpec_SupportingAlertQuery)}
	case PolicySpec_FieldPathSelectorAiAgent:
		return &PolicySpec_FieldTerminalPathArrayOfValues{PolicySpec_FieldTerminalPath: *fp, values: values.([]*PolicySpec_AIAgentHandling)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PolicySpec_FieldTerminalPath) WithIArrayItemValue(value interface{}) PolicySpec_FieldPathArrayItemValue {
	switch fp.selector {
	case PolicySpec_FieldPathSelectorSupportingQueries:
		return &PolicySpec_FieldTerminalPathArrayItemValue{PolicySpec_FieldTerminalPath: *fp, value: value.(*PolicySpec_SupportingAlertQuery)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fp.selector))
	}
}

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

type PolicySpec_FieldSubPath struct {
	selector PolicySpec_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PolicySpec_FieldPath = (*PolicySpec_FieldSubPath)(nil)

func (fps *PolicySpec_FieldSubPath) Selector() PolicySpec_FieldPathSelector {
	return fps.selector
}
func (fps *PolicySpec_FieldSubPath) AsResourceIdentitySubPath() (PolicySpecResourceIdentity_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecResourceIdentity_FieldPath)
	return res, ok
}
func (fps *PolicySpec_FieldSubPath) AsSupportingQueriesSubPath() (PolicySpecSupportingAlertQuery_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecSupportingAlertQuery_FieldPath)
	return res, ok
}
func (fps *PolicySpec_FieldSubPath) AsAiAgentSubPath() (PolicySpecAIAgentHandling_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecAIAgentHandling_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source PolicySpec
func (fps *PolicySpec_FieldSubPath) Get(source *PolicySpec) (values []interface{}) {
	switch fps.selector {
	case PolicySpec_FieldPathSelectorResourceIdentity:
		values = append(values, fps.subPath.GetRaw(source.GetResourceIdentity())...)
	case PolicySpec_FieldPathSelectorSupportingQueries:
		for _, item := range source.GetSupportingQueries() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case PolicySpec_FieldPathSelectorAiAgent:
		values = append(values, fps.subPath.GetRaw(source.GetAiAgent())...)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source PolicySpec
func (fps *PolicySpec_FieldSubPath) GetSingle(source *PolicySpec) (interface{}, bool) {
	switch fps.selector {
	case PolicySpec_FieldPathSelectorResourceIdentity:
		if source.GetResourceIdentity() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetResourceIdentity())
	case PolicySpec_FieldPathSelectorSupportingQueries:
		if len(source.GetSupportingQueries()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetSupportingQueries()[0])
	case PolicySpec_FieldPathSelectorAiAgent:
		if source.GetAiAgent() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAiAgent())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fps.selector))
	}
}

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

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

func (fps *PolicySpec_FieldSubPath) ClearValue(item *PolicySpec) {
	if item != nil {
		switch fps.selector {
		case PolicySpec_FieldPathSelectorResourceIdentity:
			fps.subPath.ClearValueRaw(item.ResourceIdentity)
		case PolicySpec_FieldPathSelectorSupportingQueries:
			for _, subItem := range item.SupportingQueries {
				fps.subPath.ClearValueRaw(subItem)
			}
		case PolicySpec_FieldPathSelectorAiAgent:
			fps.subPath.ClearValueRaw(item.AiAgent)
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fps.selector))
		}
	}
}

func (fps *PolicySpec_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PolicySpec))
}

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

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

func (fps *PolicySpec_FieldSubPath) WithIValue(value interface{}) PolicySpec_FieldPathValue {
	return &PolicySpec_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PolicySpec_FieldSubPath) WithIArrayOfValues(values interface{}) PolicySpec_FieldPathArrayOfValues {
	return &PolicySpec_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PolicySpec_FieldSubPath) WithIArrayItemValue(value interface{}) PolicySpec_FieldPathArrayItemValue {
	return &PolicySpec_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParsePolicySpec_FieldPathValue(pathStr, valueStr string) PolicySpec_FieldPathValue {
	fpv, err := ParsePolicySpec_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpec_FieldTerminalPathValue struct {
	PolicySpec_FieldTerminalPath
	value interface{}
}

var _ PolicySpec_FieldPathValue = (*PolicySpec_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PolicySpec' as interface{}
func (fpv *PolicySpec_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpec_FieldTerminalPathValue) AsEnabledValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *PolicySpec_FieldTerminalPathValue) AsProcessingLocationValue() (PolicySpec_ProcessingLocation, bool) {
	res, ok := fpv.value.(PolicySpec_ProcessingLocation)
	return res, ok
}
func (fpv *PolicySpec_FieldTerminalPathValue) AsResourceIdentityValue() (*PolicySpec_ResourceIdentity, bool) {
	res, ok := fpv.value.(*PolicySpec_ResourceIdentity)
	return res, ok
}
func (fpv *PolicySpec_FieldTerminalPathValue) AsSupportingQueriesValue() ([]*PolicySpec_SupportingAlertQuery, bool) {
	res, ok := fpv.value.([]*PolicySpec_SupportingAlertQuery)
	return res, ok
}
func (fpv *PolicySpec_FieldTerminalPathValue) AsAiAgentValue() (*PolicySpec_AIAgentHandling, bool) {
	res, ok := fpv.value.(*PolicySpec_AIAgentHandling)
	return res, ok
}

// SetTo stores value for selected field for object PolicySpec
func (fpv *PolicySpec_FieldTerminalPathValue) SetTo(target **PolicySpec) {
	if *target == nil {
		*target = new(PolicySpec)
	}
	switch fpv.selector {
	case PolicySpec_FieldPathSelectorEnabled:
		(*target).Enabled = fpv.value.(bool)
	case PolicySpec_FieldPathSelectorProcessingLocation:
		(*target).ProcessingLocation = fpv.value.(PolicySpec_ProcessingLocation)
	case PolicySpec_FieldPathSelectorResourceIdentity:
		(*target).ResourceIdentity = fpv.value.(*PolicySpec_ResourceIdentity)
	case PolicySpec_FieldPathSelectorSupportingQueries:
		(*target).SupportingQueries = fpv.value.([]*PolicySpec_SupportingAlertQuery)
	case PolicySpec_FieldPathSelectorAiAgent:
		(*target).AiAgent = fpv.value.(*PolicySpec_AIAgentHandling)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpec_FieldTerminalPathValue' with the value under path in 'PolicySpec'.
func (fpv *PolicySpec_FieldTerminalPathValue) CompareWith(source *PolicySpec) (int, bool) {
	switch fpv.selector {
	case PolicySpec_FieldPathSelectorEnabled:
		leftValue := fpv.value.(bool)
		rightValue := source.GetEnabled()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpec_FieldPathSelectorProcessingLocation:
		leftValue := fpv.value.(PolicySpec_ProcessingLocation)
		rightValue := source.GetProcessingLocation()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpec_FieldPathSelectorResourceIdentity:
		return 0, false
	case PolicySpec_FieldPathSelectorSupportingQueries:
		return 0, false
	case PolicySpec_FieldPathSelectorAiAgent:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fpv.selector))
	}
}

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

type PolicySpec_FieldSubPathValue struct {
	PolicySpec_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PolicySpec_FieldPathValue = (*PolicySpec_FieldSubPathValue)(nil)

func (fpvs *PolicySpec_FieldSubPathValue) AsResourceIdentityPathValue() (PolicySpecResourceIdentity_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecResourceIdentity_FieldPathValue)
	return res, ok
}
func (fpvs *PolicySpec_FieldSubPathValue) AsSupportingQueriesPathValue() (PolicySpecSupportingAlertQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecSupportingAlertQuery_FieldPathValue)
	return res, ok
}
func (fpvs *PolicySpec_FieldSubPathValue) AsAiAgentPathValue() (PolicySpecAIAgentHandling_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecAIAgentHandling_FieldPathValue)
	return res, ok
}

func (fpvs *PolicySpec_FieldSubPathValue) SetTo(target **PolicySpec) {
	if *target == nil {
		*target = new(PolicySpec)
	}
	switch fpvs.Selector() {
	case PolicySpec_FieldPathSelectorResourceIdentity:
		fpvs.subPathValue.(PolicySpecResourceIdentity_FieldPathValue).SetTo(&(*target).ResourceIdentity)
	case PolicySpec_FieldPathSelectorSupportingQueries:
		panic("FieldPath setter is unsupported for array subpaths")
	case PolicySpec_FieldPathSelectorAiAgent:
		fpvs.subPathValue.(PolicySpecAIAgentHandling_FieldPathValue).SetTo(&(*target).AiAgent)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PolicySpec_FieldSubPathValue) CompareWith(source *PolicySpec) (int, bool) {
	switch fpvs.Selector() {
	case PolicySpec_FieldPathSelectorResourceIdentity:
		return fpvs.subPathValue.(PolicySpecResourceIdentity_FieldPathValue).CompareWith(source.GetResourceIdentity())
	case PolicySpec_FieldPathSelectorSupportingQueries:
		return 0, false // repeated field
	case PolicySpec_FieldPathSelectorAiAgent:
		return fpvs.subPathValue.(PolicySpecAIAgentHandling_FieldPathValue).CompareWith(source.GetAiAgent())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePolicySpec_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpec_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpec_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpec_FieldTerminalPathArrayItemValue struct {
	PolicySpec_FieldTerminalPath
	value interface{}
}

var _ PolicySpec_FieldPathArrayItemValue = (*PolicySpec_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object PolicySpec as interface{}
func (fpaiv *PolicySpec_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *PolicySpec_FieldTerminalPathArrayItemValue) AsSupportingQueriesItemValue() (*PolicySpec_SupportingAlertQuery, bool) {
	res, ok := fpaiv.value.(*PolicySpec_SupportingAlertQuery)
	return res, ok
}

func (fpaiv *PolicySpec_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *PolicySpec_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PolicySpec_FieldSubPathArrayItemValue) AsResourceIdentityPathItemValue() (PolicySpecResourceIdentity_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecResourceIdentity_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PolicySpec_FieldSubPathArrayItemValue) AsSupportingQueriesPathItemValue() (PolicySpecSupportingAlertQuery_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecSupportingAlertQuery_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PolicySpec_FieldSubPathArrayItemValue) AsAiAgentPathItemValue() (PolicySpecAIAgentHandling_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecAIAgentHandling_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'PolicySpec'
func (fpaivs *PolicySpec_FieldSubPathArrayItemValue) ContainsValue(source *PolicySpec) bool {
	switch fpaivs.Selector() {
	case PolicySpec_FieldPathSelectorResourceIdentity:
		return fpaivs.subPathItemValue.(PolicySpecResourceIdentity_FieldPathArrayItemValue).ContainsValue(source.GetResourceIdentity())
	case PolicySpec_FieldPathSelectorSupportingQueries:
		return false // repeated/map field
	case PolicySpec_FieldPathSelectorAiAgent:
		return fpaivs.subPathItemValue.(PolicySpecAIAgentHandling_FieldPathArrayItemValue).ContainsValue(source.GetAiAgent())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec: %d", fpaivs.Selector()))
	}
}

// PolicySpec_FieldPathArrayOfValues allows storing slice of values for PolicySpec fields according to their type
type PolicySpec_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpec_FieldPath
}

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

func MustParsePolicySpec_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpec_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpec_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpec_FieldTerminalPathArrayOfValues struct {
	PolicySpec_FieldTerminalPath
	values interface{}
}

var _ PolicySpec_FieldPathArrayOfValues = (*PolicySpec_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpec_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpec_FieldPathSelectorEnabled:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case PolicySpec_FieldPathSelectorProcessingLocation:
		for _, v := range fpaov.values.([]PolicySpec_ProcessingLocation) {
			values = append(values, v)
		}
	case PolicySpec_FieldPathSelectorResourceIdentity:
		for _, v := range fpaov.values.([]*PolicySpec_ResourceIdentity) {
			values = append(values, v)
		}
	case PolicySpec_FieldPathSelectorSupportingQueries:
		for _, v := range fpaov.values.([][]*PolicySpec_SupportingAlertQuery) {
			values = append(values, v)
		}
	case PolicySpec_FieldPathSelectorAiAgent:
		for _, v := range fpaov.values.([]*PolicySpec_AIAgentHandling) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpec_FieldTerminalPathArrayOfValues) AsEnabledArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *PolicySpec_FieldTerminalPathArrayOfValues) AsProcessingLocationArrayOfValues() ([]PolicySpec_ProcessingLocation, bool) {
	res, ok := fpaov.values.([]PolicySpec_ProcessingLocation)
	return res, ok
}
func (fpaov *PolicySpec_FieldTerminalPathArrayOfValues) AsResourceIdentityArrayOfValues() ([]*PolicySpec_ResourceIdentity, bool) {
	res, ok := fpaov.values.([]*PolicySpec_ResourceIdentity)
	return res, ok
}
func (fpaov *PolicySpec_FieldTerminalPathArrayOfValues) AsSupportingQueriesArrayOfValues() ([][]*PolicySpec_SupportingAlertQuery, bool) {
	res, ok := fpaov.values.([][]*PolicySpec_SupportingAlertQuery)
	return res, ok
}
func (fpaov *PolicySpec_FieldTerminalPathArrayOfValues) AsAiAgentArrayOfValues() ([]*PolicySpec_AIAgentHandling, bool) {
	res, ok := fpaov.values.([]*PolicySpec_AIAgentHandling)
	return res, ok
}

type PolicySpec_FieldSubPathArrayOfValues struct {
	PolicySpec_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PolicySpec_FieldPathArrayOfValues = (*PolicySpec_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PolicySpec_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PolicySpec_FieldSubPathArrayOfValues) AsResourceIdentityPathArrayOfValues() (PolicySpecResourceIdentity_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecResourceIdentity_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PolicySpec_FieldSubPathArrayOfValues) AsSupportingQueriesPathArrayOfValues() (PolicySpecSupportingAlertQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecSupportingAlertQuery_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PolicySpec_FieldSubPathArrayOfValues) AsAiAgentPathArrayOfValues() (PolicySpecAIAgentHandling_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecAIAgentHandling_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PolicySpecResourceIdentity_FieldPathSelector int32

const (
	PolicySpecResourceIdentity_FieldPathSelectorAlertingResource PolicySpecResourceIdentity_FieldPathSelector = 0
	PolicySpecResourceIdentity_FieldPathSelectorLabels           PolicySpecResourceIdentity_FieldPathSelector = 1
	PolicySpecResourceIdentity_FieldPathSelectorNamePatterns     PolicySpecResourceIdentity_FieldPathSelector = 2
)

func (s PolicySpecResourceIdentity_FieldPathSelector) String() string {
	switch s {
	case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
		return "alerting_resource"
	case PolicySpecResourceIdentity_FieldPathSelectorLabels:
		return "labels"
	case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
		return "name_patterns"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", s))
	}
}

func BuildPolicySpecResourceIdentity_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecResourceIdentity_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_ResourceIdentity")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "alerting_resource", "alertingResource", "alerting-resource":
			return &PolicySpecResourceIdentity_FieldTerminalPath{selector: PolicySpecResourceIdentity_FieldPathSelectorAlertingResource}, nil
		case "labels":
			return &PolicySpecResourceIdentity_FieldTerminalPath{selector: PolicySpecResourceIdentity_FieldPathSelectorLabels}, nil
		case "name_patterns", "namePatterns", "name-patterns":
			return &PolicySpecResourceIdentity_FieldTerminalPath{selector: PolicySpecResourceIdentity_FieldPathSelectorNamePatterns}, nil
		}
	} else {
		switch fp[0] {
		case "labels":
			if subpath, err := BuildPolicySpecResourceIdentityLabelInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecResourceIdentity_FieldSubPath{selector: PolicySpecResourceIdentity_FieldPathSelectorLabels, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_ResourceIdentity", fp)
}

func ParsePolicySpecResourceIdentity_FieldPath(rawField string) (PolicySpecResourceIdentity_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecResourceIdentity_FieldPath(fp)
}

func MustParsePolicySpecResourceIdentity_FieldPath(rawField string) PolicySpecResourceIdentity_FieldPath {
	fp, err := ParsePolicySpecResourceIdentity_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecResourceIdentity_FieldTerminalPath struct {
	selector PolicySpecResourceIdentity_FieldPathSelector
}

var _ PolicySpecResourceIdentity_FieldPath = (*PolicySpecResourceIdentity_FieldTerminalPath)(nil)

func (fp *PolicySpecResourceIdentity_FieldTerminalPath) Selector() PolicySpecResourceIdentity_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_ResourceIdentity
func (fp *PolicySpecResourceIdentity_FieldTerminalPath) Get(source *PolicySpec_ResourceIdentity) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
			if source.AlertingResource != nil {
				values = append(values, source.AlertingResource)
			}
		case PolicySpecResourceIdentity_FieldPathSelectorLabels:
			for _, value := range source.GetLabels() {
				values = append(values, value)
			}
		case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
			for _, value := range source.GetNamePatterns() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_ResourceIdentity
func (fp *PolicySpecResourceIdentity_FieldTerminalPath) GetSingle(source *PolicySpec_ResourceIdentity) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
		res := source.GetAlertingResource()
		return res, res != nil
	case PolicySpecResourceIdentity_FieldPathSelectorLabels:
		res := source.GetLabels()
		return res, res != nil
	case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
		res := source.GetNamePatterns()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecResourceIdentity_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
		return (*meta_resource.Reference)(nil)
	case PolicySpecResourceIdentity_FieldPathSelectorLabels:
		return ([]*PolicySpec_ResourceIdentity_LabelInfo)(nil)
	case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
		return ([]string)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", fp.selector))
	}
}

func (fp *PolicySpecResourceIdentity_FieldTerminalPath) ClearValue(item *PolicySpec_ResourceIdentity) {
	if item != nil {
		switch fp.selector {
		case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
			item.AlertingResource = nil
		case PolicySpecResourceIdentity_FieldPathSelectorLabels:
			item.Labels = nil
		case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
			item.NamePatterns = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecResourceIdentity_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_ResourceIdentity))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpecResourceIdentity_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpecResourceIdentity_FieldPathSelectorAlertingResource ||
		fp.selector == PolicySpecResourceIdentity_FieldPathSelectorNamePatterns
}

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

func (fp *PolicySpecResourceIdentity_FieldTerminalPath) WithIValue(value interface{}) PolicySpecResourceIdentity_FieldPathValue {
	switch fp.selector {
	case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
		return &PolicySpecResourceIdentity_FieldTerminalPathValue{PolicySpecResourceIdentity_FieldTerminalPath: *fp, value: value.(*meta_resource.Reference)}
	case PolicySpecResourceIdentity_FieldPathSelectorLabels:
		return &PolicySpecResourceIdentity_FieldTerminalPathValue{PolicySpecResourceIdentity_FieldTerminalPath: *fp, value: value.([]*PolicySpec_ResourceIdentity_LabelInfo)}
	case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
		return &PolicySpecResourceIdentity_FieldTerminalPathValue{PolicySpecResourceIdentity_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", fp.selector))
	}
}

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

func (fp *PolicySpecResourceIdentity_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecResourceIdentity_FieldPathArrayOfValues {
	fpaov := &PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues{PolicySpecResourceIdentity_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
		return &PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues{PolicySpecResourceIdentity_FieldTerminalPath: *fp, values: values.([]*meta_resource.Reference)}
	case PolicySpecResourceIdentity_FieldPathSelectorLabels:
		return &PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues{PolicySpecResourceIdentity_FieldTerminalPath: *fp, values: values.([][]*PolicySpec_ResourceIdentity_LabelInfo)}
	case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
		return &PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues{PolicySpecResourceIdentity_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PolicySpecResourceIdentity_FieldTerminalPath) WithIArrayItemValue(value interface{}) PolicySpecResourceIdentity_FieldPathArrayItemValue {
	switch fp.selector {
	case PolicySpecResourceIdentity_FieldPathSelectorLabels:
		return &PolicySpecResourceIdentity_FieldTerminalPathArrayItemValue{PolicySpecResourceIdentity_FieldTerminalPath: *fp, value: value.(*PolicySpec_ResourceIdentity_LabelInfo)}
	case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
		return &PolicySpecResourceIdentity_FieldTerminalPathArrayItemValue{PolicySpecResourceIdentity_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", fp.selector))
	}
}

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

type PolicySpecResourceIdentity_FieldSubPath struct {
	selector PolicySpecResourceIdentity_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PolicySpecResourceIdentity_FieldPath = (*PolicySpecResourceIdentity_FieldSubPath)(nil)

func (fps *PolicySpecResourceIdentity_FieldSubPath) Selector() PolicySpecResourceIdentity_FieldPathSelector {
	return fps.selector
}
func (fps *PolicySpecResourceIdentity_FieldSubPath) AsLabelsSubPath() (PolicySpecResourceIdentityLabelInfo_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecResourceIdentityLabelInfo_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *PolicySpecResourceIdentity_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PolicySpec_ResourceIdentity))
}

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

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

func (fps *PolicySpecResourceIdentity_FieldSubPath) WithIValue(value interface{}) PolicySpecResourceIdentity_FieldPathValue {
	return &PolicySpecResourceIdentity_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PolicySpecResourceIdentity_FieldSubPath) WithIArrayOfValues(values interface{}) PolicySpecResourceIdentity_FieldPathArrayOfValues {
	return &PolicySpecResourceIdentity_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PolicySpecResourceIdentity_FieldSubPath) WithIArrayItemValue(value interface{}) PolicySpecResourceIdentity_FieldPathArrayItemValue {
	return &PolicySpecResourceIdentity_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PolicySpecResourceIdentity_FieldPathValue allows storing values for ResourceIdentity fields according to their type
type PolicySpecResourceIdentity_FieldPathValue interface {
	PolicySpecResourceIdentity_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_ResourceIdentity)
	CompareWith(*PolicySpec_ResourceIdentity) (cmp int, comparable bool)
}

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

func MustParsePolicySpecResourceIdentity_FieldPathValue(pathStr, valueStr string) PolicySpecResourceIdentity_FieldPathValue {
	fpv, err := ParsePolicySpecResourceIdentity_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecResourceIdentity_FieldTerminalPathValue struct {
	PolicySpecResourceIdentity_FieldTerminalPath
	value interface{}
}

var _ PolicySpecResourceIdentity_FieldPathValue = (*PolicySpecResourceIdentity_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ResourceIdentity' as interface{}
func (fpv *PolicySpecResourceIdentity_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecResourceIdentity_FieldTerminalPathValue) AsAlertingResourceValue() (*meta_resource.Reference, bool) {
	res, ok := fpv.value.(*meta_resource.Reference)
	return res, ok
}
func (fpv *PolicySpecResourceIdentity_FieldTerminalPathValue) AsLabelsValue() ([]*PolicySpec_ResourceIdentity_LabelInfo, bool) {
	res, ok := fpv.value.([]*PolicySpec_ResourceIdentity_LabelInfo)
	return res, ok
}
func (fpv *PolicySpecResourceIdentity_FieldTerminalPathValue) AsNamePatternsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object ResourceIdentity
func (fpv *PolicySpecResourceIdentity_FieldTerminalPathValue) SetTo(target **PolicySpec_ResourceIdentity) {
	if *target == nil {
		*target = new(PolicySpec_ResourceIdentity)
	}
	switch fpv.selector {
	case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
		(*target).AlertingResource = fpv.value.(*meta_resource.Reference)
	case PolicySpecResourceIdentity_FieldPathSelectorLabels:
		(*target).Labels = fpv.value.([]*PolicySpec_ResourceIdentity_LabelInfo)
	case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
		(*target).NamePatterns = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpecResourceIdentity_FieldTerminalPathValue' with the value under path in 'PolicySpec_ResourceIdentity'.
func (fpv *PolicySpecResourceIdentity_FieldTerminalPathValue) CompareWith(source *PolicySpec_ResourceIdentity) (int, bool) {
	switch fpv.selector {
	case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
		leftValue := fpv.value.(*meta_resource.Reference)
		rightValue := source.GetAlertingResource()
		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 PolicySpecResourceIdentity_FieldPathSelectorLabels:
		return 0, false
	case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity: %d", fpv.selector))
	}
}

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

type PolicySpecResourceIdentity_FieldSubPathValue struct {
	PolicySpecResourceIdentity_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PolicySpecResourceIdentity_FieldPathValue = (*PolicySpecResourceIdentity_FieldSubPathValue)(nil)

func (fpvs *PolicySpecResourceIdentity_FieldSubPathValue) AsLabelsPathValue() (PolicySpecResourceIdentityLabelInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecResourceIdentityLabelInfo_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParsePolicySpecResourceIdentity_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecResourceIdentity_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecResourceIdentity_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecResourceIdentity_FieldTerminalPathArrayItemValue struct {
	PolicySpecResourceIdentity_FieldTerminalPath
	value interface{}
}

var _ PolicySpecResourceIdentity_FieldPathArrayItemValue = (*PolicySpecResourceIdentity_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object PolicySpec_ResourceIdentity as interface{}
func (fpaiv *PolicySpecResourceIdentity_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *PolicySpecResourceIdentity_FieldTerminalPathArrayItemValue) AsLabelsItemValue() (*PolicySpec_ResourceIdentity_LabelInfo, bool) {
	res, ok := fpaiv.value.(*PolicySpec_ResourceIdentity_LabelInfo)
	return res, ok
}
func (fpaiv *PolicySpecResourceIdentity_FieldTerminalPathArrayItemValue) AsNamePatternsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *PolicySpecResourceIdentity_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_ResourceIdentity) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ResourceIdentity'
func (fpaiv *PolicySpecResourceIdentity_FieldTerminalPathArrayItemValue) ContainsValue(source *PolicySpec_ResourceIdentity) bool {
	slice := fpaiv.PolicySpecResourceIdentity_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 PolicySpecResourceIdentity_FieldSubPathArrayItemValue struct {
	PolicySpecResourceIdentity_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// PolicySpecResourceIdentity_FieldPathArrayOfValues allows storing slice of values for ResourceIdentity fields according to their type
type PolicySpecResourceIdentity_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecResourceIdentity_FieldPath
}

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

func MustParsePolicySpecResourceIdentity_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecResourceIdentity_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecResourceIdentity_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues struct {
	PolicySpecResourceIdentity_FieldTerminalPath
	values interface{}
}

var _ PolicySpecResourceIdentity_FieldPathArrayOfValues = (*PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecResourceIdentity_FieldPathSelectorAlertingResource:
		for _, v := range fpaov.values.([]*meta_resource.Reference) {
			values = append(values, v)
		}
	case PolicySpecResourceIdentity_FieldPathSelectorLabels:
		for _, v := range fpaov.values.([][]*PolicySpec_ResourceIdentity_LabelInfo) {
			values = append(values, v)
		}
	case PolicySpecResourceIdentity_FieldPathSelectorNamePatterns:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues) AsAlertingResourceArrayOfValues() ([]*meta_resource.Reference, bool) {
	res, ok := fpaov.values.([]*meta_resource.Reference)
	return res, ok
}
func (fpaov *PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues) AsLabelsArrayOfValues() ([][]*PolicySpec_ResourceIdentity_LabelInfo, bool) {
	res, ok := fpaov.values.([][]*PolicySpec_ResourceIdentity_LabelInfo)
	return res, ok
}
func (fpaov *PolicySpecResourceIdentity_FieldTerminalPathArrayOfValues) AsNamePatternsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}

type PolicySpecResourceIdentity_FieldSubPathArrayOfValues struct {
	PolicySpecResourceIdentity_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PolicySpecResourceIdentity_FieldPathArrayOfValues = (*PolicySpecResourceIdentity_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PolicySpecResourceIdentity_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PolicySpecResourceIdentity_FieldSubPathArrayOfValues) AsLabelsPathArrayOfValues() (PolicySpecResourceIdentityLabelInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecResourceIdentityLabelInfo_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PolicySpecSupportingAlertQuery_FieldPathSelector int32

const (
	PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery       PolicySpecSupportingAlertQuery_FieldPathSelector = 0
	PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery      PolicySpecSupportingAlertQuery_FieldPathSelector = 1
	PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery  PolicySpecSupportingAlertQuery_FieldPathSelector = 2
	PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery PolicySpecSupportingAlertQuery_FieldPathSelector = 3
)

func (s PolicySpecSupportingAlertQuery_FieldPathSelector) String() string {
	switch s {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		return "ts_query"
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		return "log_query"
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		return "rest_get_query"
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		return "rest_list_query"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", s))
	}
}

func BuildPolicySpecSupportingAlertQuery_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecSupportingAlertQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_SupportingAlertQuery")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "ts_query", "tsQuery", "ts-query":
			return &PolicySpecSupportingAlertQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery}, nil
		case "log_query", "logQuery", "log-query":
			return &PolicySpecSupportingAlertQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery}, nil
		case "rest_get_query", "restGetQuery", "rest-get-query":
			return &PolicySpecSupportingAlertQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery}, nil
		case "rest_list_query", "restListQuery", "rest-list-query":
			return &PolicySpecSupportingAlertQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery}, nil
		}
	} else {
		switch fp[0] {
		case "ts_query", "tsQuery", "ts-query":
			if subpath, err := BuildPolicySpecSupportingAlertQueryTsQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecSupportingAlertQuery_FieldSubPath{selector: PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery, subPath: subpath}, nil
			}
		case "log_query", "logQuery", "log-query":
			if subpath, err := BuildPolicySpecSupportingAlertQueryLogQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecSupportingAlertQuery_FieldSubPath{selector: PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery, subPath: subpath}, nil
			}
		case "rest_get_query", "restGetQuery", "rest-get-query":
			if subpath, err := BuildPolicySpecSupportingAlertQueryRestGetQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecSupportingAlertQuery_FieldSubPath{selector: PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery, subPath: subpath}, nil
			}
		case "rest_list_query", "restListQuery", "rest-list-query":
			if subpath, err := BuildPolicySpecSupportingAlertQueryRestListQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecSupportingAlertQuery_FieldSubPath{selector: PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_SupportingAlertQuery", fp)
}

func ParsePolicySpecSupportingAlertQuery_FieldPath(rawField string) (PolicySpecSupportingAlertQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecSupportingAlertQuery_FieldPath(fp)
}

func MustParsePolicySpecSupportingAlertQuery_FieldPath(rawField string) PolicySpecSupportingAlertQuery_FieldPath {
	fp, err := ParsePolicySpecSupportingAlertQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecSupportingAlertQuery_FieldTerminalPath struct {
	selector PolicySpecSupportingAlertQuery_FieldPathSelector
}

var _ PolicySpecSupportingAlertQuery_FieldPath = (*PolicySpecSupportingAlertQuery_FieldTerminalPath)(nil)

func (fp *PolicySpecSupportingAlertQuery_FieldTerminalPath) Selector() PolicySpecSupportingAlertQuery_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_SupportingAlertQuery
func (fp *PolicySpecSupportingAlertQuery_FieldTerminalPath) Get(source *PolicySpec_SupportingAlertQuery) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
			if source, ok := source.Query.(*PolicySpec_SupportingAlertQuery_TsQuery_); ok && source != nil {
				if source.TsQuery != nil {
					values = append(values, source.TsQuery)
				}
			}
		case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
			if source, ok := source.Query.(*PolicySpec_SupportingAlertQuery_LogQuery_); ok && source != nil {
				if source.LogQuery != nil {
					values = append(values, source.LogQuery)
				}
			}
		case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
			if source, ok := source.Query.(*PolicySpec_SupportingAlertQuery_RestGetQuery_); ok && source != nil {
				if source.RestGetQuery != nil {
					values = append(values, source.RestGetQuery)
				}
			}
		case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
			if source, ok := source.Query.(*PolicySpec_SupportingAlertQuery_RestListQuery_); ok && source != nil {
				if source.RestListQuery != nil {
					values = append(values, source.RestListQuery)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_SupportingAlertQuery
func (fp *PolicySpecSupportingAlertQuery_FieldTerminalPath) GetSingle(source *PolicySpec_SupportingAlertQuery) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetTsQuery(), false
		}
		_, oneOfSelected := source.Query.(*PolicySpec_SupportingAlertQuery_TsQuery_)
		if !oneOfSelected {
			return source.GetTsQuery(), false // to return "type" information
		}
		res := source.GetTsQuery()
		return res, res != nil
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetLogQuery(), false
		}
		_, oneOfSelected := source.Query.(*PolicySpec_SupportingAlertQuery_LogQuery_)
		if !oneOfSelected {
			return source.GetLogQuery(), false // to return "type" information
		}
		res := source.GetLogQuery()
		return res, res != nil
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetRestGetQuery(), false
		}
		_, oneOfSelected := source.Query.(*PolicySpec_SupportingAlertQuery_RestGetQuery_)
		if !oneOfSelected {
			return source.GetRestGetQuery(), false // to return "type" information
		}
		res := source.GetRestGetQuery()
		return res, res != nil
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetRestListQuery(), false
		}
		_, oneOfSelected := source.Query.(*PolicySpec_SupportingAlertQuery_RestListQuery_)
		if !oneOfSelected {
			return source.GetRestListQuery(), false // to return "type" information
		}
		res := source.GetRestListQuery()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecSupportingAlertQuery_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		return (*PolicySpec_SupportingAlertQuery_TsQuery)(nil)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		return (*PolicySpec_SupportingAlertQuery_LogQuery)(nil)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		return (*PolicySpec_SupportingAlertQuery_RestGetQuery)(nil)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		return (*PolicySpec_SupportingAlertQuery_RestListQuery)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fp.selector))
	}
}

func (fp *PolicySpecSupportingAlertQuery_FieldTerminalPath) ClearValue(item *PolicySpec_SupportingAlertQuery) {
	if item != nil {
		switch fp.selector {
		case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
			if item, ok := item.Query.(*PolicySpec_SupportingAlertQuery_TsQuery_); ok {
				item.TsQuery = nil
			}
		case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
			if item, ok := item.Query.(*PolicySpec_SupportingAlertQuery_LogQuery_); ok {
				item.LogQuery = nil
			}
		case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
			if item, ok := item.Query.(*PolicySpec_SupportingAlertQuery_RestGetQuery_); ok {
				item.RestGetQuery = nil
			}
		case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
			if item, ok := item.Query.(*PolicySpec_SupportingAlertQuery_RestListQuery_); ok {
				item.RestListQuery = nil
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecSupportingAlertQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_SupportingAlertQuery))
}

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

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

func (fp *PolicySpecSupportingAlertQuery_FieldTerminalPath) WithIValue(value interface{}) PolicySpecSupportingAlertQuery_FieldPathValue {
	switch fp.selector {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		return &PolicySpecSupportingAlertQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQuery_FieldTerminalPath: *fp, value: value.(*PolicySpec_SupportingAlertQuery_TsQuery)}
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		return &PolicySpecSupportingAlertQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQuery_FieldTerminalPath: *fp, value: value.(*PolicySpec_SupportingAlertQuery_LogQuery)}
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		return &PolicySpecSupportingAlertQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQuery_FieldTerminalPath: *fp, value: value.(*PolicySpec_SupportingAlertQuery_RestGetQuery)}
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		return &PolicySpecSupportingAlertQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQuery_FieldTerminalPath: *fp, value: value.(*PolicySpec_SupportingAlertQuery_RestListQuery)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fp.selector))
	}
}

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

func (fp *PolicySpecSupportingAlertQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecSupportingAlertQuery_FieldPathArrayOfValues {
	fpaov := &PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		return &PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQuery_FieldTerminalPath: *fp, values: values.([]*PolicySpec_SupportingAlertQuery_TsQuery)}
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		return &PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQuery_FieldTerminalPath: *fp, values: values.([]*PolicySpec_SupportingAlertQuery_LogQuery)}
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		return &PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQuery_FieldTerminalPath: *fp, values: values.([]*PolicySpec_SupportingAlertQuery_RestGetQuery)}
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		return &PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQuery_FieldTerminalPath: *fp, values: values.([]*PolicySpec_SupportingAlertQuery_RestListQuery)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type PolicySpecSupportingAlertQuery_FieldSubPath struct {
	selector PolicySpecSupportingAlertQuery_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PolicySpecSupportingAlertQuery_FieldPath = (*PolicySpecSupportingAlertQuery_FieldSubPath)(nil)

func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) Selector() PolicySpecSupportingAlertQuery_FieldPathSelector {
	return fps.selector
}
func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) AsTsQuerySubPath() (PolicySpecSupportingAlertQueryTsQuery_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecSupportingAlertQueryTsQuery_FieldPath)
	return res, ok
}
func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) AsLogQuerySubPath() (PolicySpecSupportingAlertQueryLogQuery_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecSupportingAlertQueryLogQuery_FieldPath)
	return res, ok
}
func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) AsRestGetQuerySubPath() (PolicySpecSupportingAlertQueryRestGetQuery_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecSupportingAlertQueryRestGetQuery_FieldPath)
	return res, ok
}
func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) AsRestListQuerySubPath() (PolicySpecSupportingAlertQueryRestListQuery_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecSupportingAlertQueryRestListQuery_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source PolicySpec_SupportingAlertQuery
func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) Get(source *PolicySpec_SupportingAlertQuery) (values []interface{}) {
	switch fps.selector {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		values = append(values, fps.subPath.GetRaw(source.GetTsQuery())...)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		values = append(values, fps.subPath.GetRaw(source.GetLogQuery())...)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		values = append(values, fps.subPath.GetRaw(source.GetRestGetQuery())...)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		values = append(values, fps.subPath.GetRaw(source.GetRestListQuery())...)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source PolicySpec_SupportingAlertQuery
func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) GetSingle(source *PolicySpec_SupportingAlertQuery) (interface{}, bool) {
	switch fps.selector {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		if source.GetTsQuery() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetTsQuery())
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		if source.GetLogQuery() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetLogQuery())
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		if source.GetRestGetQuery() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetRestGetQuery())
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		if source.GetRestListQuery() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetRestListQuery())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fps.selector))
	}
}

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

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

func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) ClearValue(item *PolicySpec_SupportingAlertQuery) {
	if item != nil {
		switch fps.selector {
		case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
			if item.Query != nil {
				if item, ok := item.Query.(*PolicySpec_SupportingAlertQuery_TsQuery_); ok {
					fps.subPath.ClearValueRaw(item.TsQuery)
				}
			}
		case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
			if item.Query != nil {
				if item, ok := item.Query.(*PolicySpec_SupportingAlertQuery_LogQuery_); ok {
					fps.subPath.ClearValueRaw(item.LogQuery)
				}
			}
		case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
			if item.Query != nil {
				if item, ok := item.Query.(*PolicySpec_SupportingAlertQuery_RestGetQuery_); ok {
					fps.subPath.ClearValueRaw(item.RestGetQuery)
				}
			}
		case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
			if item.Query != nil {
				if item, ok := item.Query.(*PolicySpec_SupportingAlertQuery_RestListQuery_); ok {
					fps.subPath.ClearValueRaw(item.RestListQuery)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fps.selector))
		}
	}
}

func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PolicySpec_SupportingAlertQuery))
}

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

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

func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) WithIValue(value interface{}) PolicySpecSupportingAlertQuery_FieldPathValue {
	return &PolicySpecSupportingAlertQuery_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) WithIArrayOfValues(values interface{}) PolicySpecSupportingAlertQuery_FieldPathArrayOfValues {
	return &PolicySpecSupportingAlertQuery_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PolicySpecSupportingAlertQuery_FieldSubPath) WithIArrayItemValue(value interface{}) PolicySpecSupportingAlertQuery_FieldPathArrayItemValue {
	return &PolicySpecSupportingAlertQuery_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PolicySpecSupportingAlertQuery_FieldPathValue allows storing values for SupportingAlertQuery fields according to their type
type PolicySpecSupportingAlertQuery_FieldPathValue interface {
	PolicySpecSupportingAlertQuery_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_SupportingAlertQuery)
	CompareWith(*PolicySpec_SupportingAlertQuery) (cmp int, comparable bool)
}

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

func MustParsePolicySpecSupportingAlertQuery_FieldPathValue(pathStr, valueStr string) PolicySpecSupportingAlertQuery_FieldPathValue {
	fpv, err := ParsePolicySpecSupportingAlertQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecSupportingAlertQuery_FieldTerminalPathValue struct {
	PolicySpecSupportingAlertQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQuery_FieldPathValue = (*PolicySpecSupportingAlertQuery_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'SupportingAlertQuery' as interface{}
func (fpv *PolicySpecSupportingAlertQuery_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecSupportingAlertQuery_FieldTerminalPathValue) AsTsQueryValue() (*PolicySpec_SupportingAlertQuery_TsQuery, bool) {
	res, ok := fpv.value.(*PolicySpec_SupportingAlertQuery_TsQuery)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQuery_FieldTerminalPathValue) AsLogQueryValue() (*PolicySpec_SupportingAlertQuery_LogQuery, bool) {
	res, ok := fpv.value.(*PolicySpec_SupportingAlertQuery_LogQuery)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQuery_FieldTerminalPathValue) AsRestGetQueryValue() (*PolicySpec_SupportingAlertQuery_RestGetQuery, bool) {
	res, ok := fpv.value.(*PolicySpec_SupportingAlertQuery_RestGetQuery)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQuery_FieldTerminalPathValue) AsRestListQueryValue() (*PolicySpec_SupportingAlertQuery_RestListQuery, bool) {
	res, ok := fpv.value.(*PolicySpec_SupportingAlertQuery_RestListQuery)
	return res, ok
}

// SetTo stores value for selected field for object SupportingAlertQuery
func (fpv *PolicySpecSupportingAlertQuery_FieldTerminalPathValue) SetTo(target **PolicySpec_SupportingAlertQuery) {
	if *target == nil {
		*target = new(PolicySpec_SupportingAlertQuery)
	}
	switch fpv.selector {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		if _, ok := (*target).Query.(*PolicySpec_SupportingAlertQuery_TsQuery_); !ok {
			(*target).Query = &PolicySpec_SupportingAlertQuery_TsQuery_{}
		}
		(*target).Query.(*PolicySpec_SupportingAlertQuery_TsQuery_).TsQuery = fpv.value.(*PolicySpec_SupportingAlertQuery_TsQuery)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		if _, ok := (*target).Query.(*PolicySpec_SupportingAlertQuery_LogQuery_); !ok {
			(*target).Query = &PolicySpec_SupportingAlertQuery_LogQuery_{}
		}
		(*target).Query.(*PolicySpec_SupportingAlertQuery_LogQuery_).LogQuery = fpv.value.(*PolicySpec_SupportingAlertQuery_LogQuery)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		if _, ok := (*target).Query.(*PolicySpec_SupportingAlertQuery_RestGetQuery_); !ok {
			(*target).Query = &PolicySpec_SupportingAlertQuery_RestGetQuery_{}
		}
		(*target).Query.(*PolicySpec_SupportingAlertQuery_RestGetQuery_).RestGetQuery = fpv.value.(*PolicySpec_SupportingAlertQuery_RestGetQuery)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		if _, ok := (*target).Query.(*PolicySpec_SupportingAlertQuery_RestListQuery_); !ok {
			(*target).Query = &PolicySpec_SupportingAlertQuery_RestListQuery_{}
		}
		(*target).Query.(*PolicySpec_SupportingAlertQuery_RestListQuery_).RestListQuery = fpv.value.(*PolicySpec_SupportingAlertQuery_RestListQuery)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fpv.selector))
	}
}

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

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

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

type PolicySpecSupportingAlertQuery_FieldSubPathValue struct {
	PolicySpecSupportingAlertQuery_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PolicySpecSupportingAlertQuery_FieldPathValue = (*PolicySpecSupportingAlertQuery_FieldSubPathValue)(nil)

func (fpvs *PolicySpecSupportingAlertQuery_FieldSubPathValue) AsTsQueryPathValue() (PolicySpecSupportingAlertQueryTsQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecSupportingAlertQueryTsQuery_FieldPathValue)
	return res, ok
}
func (fpvs *PolicySpecSupportingAlertQuery_FieldSubPathValue) AsLogQueryPathValue() (PolicySpecSupportingAlertQueryLogQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecSupportingAlertQueryLogQuery_FieldPathValue)
	return res, ok
}
func (fpvs *PolicySpecSupportingAlertQuery_FieldSubPathValue) AsRestGetQueryPathValue() (PolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue)
	return res, ok
}
func (fpvs *PolicySpecSupportingAlertQuery_FieldSubPathValue) AsRestListQueryPathValue() (PolicySpecSupportingAlertQueryRestListQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecSupportingAlertQueryRestListQuery_FieldPathValue)
	return res, ok
}

func (fpvs *PolicySpecSupportingAlertQuery_FieldSubPathValue) SetTo(target **PolicySpec_SupportingAlertQuery) {
	if *target == nil {
		*target = new(PolicySpec_SupportingAlertQuery)
	}
	switch fpvs.Selector() {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		if _, ok := (*target).Query.(*PolicySpec_SupportingAlertQuery_TsQuery_); !ok {
			(*target).Query = &PolicySpec_SupportingAlertQuery_TsQuery_{}
		}
		fpvs.subPathValue.(PolicySpecSupportingAlertQueryTsQuery_FieldPathValue).SetTo(&(*target).Query.(*PolicySpec_SupportingAlertQuery_TsQuery_).TsQuery)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		if _, ok := (*target).Query.(*PolicySpec_SupportingAlertQuery_LogQuery_); !ok {
			(*target).Query = &PolicySpec_SupportingAlertQuery_LogQuery_{}
		}
		fpvs.subPathValue.(PolicySpecSupportingAlertQueryLogQuery_FieldPathValue).SetTo(&(*target).Query.(*PolicySpec_SupportingAlertQuery_LogQuery_).LogQuery)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		if _, ok := (*target).Query.(*PolicySpec_SupportingAlertQuery_RestGetQuery_); !ok {
			(*target).Query = &PolicySpec_SupportingAlertQuery_RestGetQuery_{}
		}
		fpvs.subPathValue.(PolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue).SetTo(&(*target).Query.(*PolicySpec_SupportingAlertQuery_RestGetQuery_).RestGetQuery)
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		if _, ok := (*target).Query.(*PolicySpec_SupportingAlertQuery_RestListQuery_); !ok {
			(*target).Query = &PolicySpec_SupportingAlertQuery_RestListQuery_{}
		}
		fpvs.subPathValue.(PolicySpecSupportingAlertQueryRestListQuery_FieldPathValue).SetTo(&(*target).Query.(*PolicySpec_SupportingAlertQuery_RestListQuery_).RestListQuery)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PolicySpecSupportingAlertQuery_FieldSubPathValue) CompareWith(source *PolicySpec_SupportingAlertQuery) (int, bool) {
	switch fpvs.Selector() {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		return fpvs.subPathValue.(PolicySpecSupportingAlertQueryTsQuery_FieldPathValue).CompareWith(source.GetTsQuery())
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		return fpvs.subPathValue.(PolicySpecSupportingAlertQueryLogQuery_FieldPathValue).CompareWith(source.GetLogQuery())
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		return fpvs.subPathValue.(PolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue).CompareWith(source.GetRestGetQuery())
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		return fpvs.subPathValue.(PolicySpecSupportingAlertQueryRestListQuery_FieldPathValue).CompareWith(source.GetRestListQuery())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePolicySpecSupportingAlertQuery_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecSupportingAlertQuery_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecSupportingAlertQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecSupportingAlertQuery_FieldTerminalPathArrayItemValue struct {
	PolicySpecSupportingAlertQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQuery_FieldPathArrayItemValue = (*PolicySpecSupportingAlertQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecSupportingAlertQuery_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_SupportingAlertQuery) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'SupportingAlertQuery'
func (fpaiv *PolicySpecSupportingAlertQuery_FieldTerminalPathArrayItemValue) ContainsValue(source *PolicySpec_SupportingAlertQuery) bool {
	slice := fpaiv.PolicySpecSupportingAlertQuery_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 PolicySpecSupportingAlertQuery_FieldSubPathArrayItemValue struct {
	PolicySpecSupportingAlertQuery_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PolicySpecSupportingAlertQuery_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PolicySpecSupportingAlertQuery_FieldSubPathArrayItemValue) AsTsQueryPathItemValue() (PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PolicySpecSupportingAlertQuery_FieldSubPathArrayItemValue) AsLogQueryPathItemValue() (PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PolicySpecSupportingAlertQuery_FieldSubPathArrayItemValue) AsRestGetQueryPathItemValue() (PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PolicySpecSupportingAlertQuery_FieldSubPathArrayItemValue) AsRestListQueryPathItemValue() (PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'SupportingAlertQuery'
func (fpaivs *PolicySpecSupportingAlertQuery_FieldSubPathArrayItemValue) ContainsValue(source *PolicySpec_SupportingAlertQuery) bool {
	switch fpaivs.Selector() {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		return fpaivs.subPathItemValue.(PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayItemValue).ContainsValue(source.GetTsQuery())
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		return fpaivs.subPathItemValue.(PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayItemValue).ContainsValue(source.GetLogQuery())
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		return fpaivs.subPathItemValue.(PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayItemValue).ContainsValue(source.GetRestGetQuery())
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		return fpaivs.subPathItemValue.(PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayItemValue).ContainsValue(source.GetRestListQuery())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery: %d", fpaivs.Selector()))
	}
}

// PolicySpecSupportingAlertQuery_FieldPathArrayOfValues allows storing slice of values for SupportingAlertQuery fields according to their type
type PolicySpecSupportingAlertQuery_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecSupportingAlertQuery_FieldPath
}

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

func MustParsePolicySpecSupportingAlertQuery_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecSupportingAlertQuery_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecSupportingAlertQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues struct {
	PolicySpecSupportingAlertQuery_FieldTerminalPath
	values interface{}
}

var _ PolicySpecSupportingAlertQuery_FieldPathArrayOfValues = (*PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecSupportingAlertQuery_FieldPathSelectorTsQuery:
		for _, v := range fpaov.values.([]*PolicySpec_SupportingAlertQuery_TsQuery) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQuery_FieldPathSelectorLogQuery:
		for _, v := range fpaov.values.([]*PolicySpec_SupportingAlertQuery_LogQuery) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestGetQuery:
		for _, v := range fpaov.values.([]*PolicySpec_SupportingAlertQuery_RestGetQuery) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQuery_FieldPathSelectorRestListQuery:
		for _, v := range fpaov.values.([]*PolicySpec_SupportingAlertQuery_RestListQuery) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues) AsTsQueryArrayOfValues() ([]*PolicySpec_SupportingAlertQuery_TsQuery, bool) {
	res, ok := fpaov.values.([]*PolicySpec_SupportingAlertQuery_TsQuery)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues) AsLogQueryArrayOfValues() ([]*PolicySpec_SupportingAlertQuery_LogQuery, bool) {
	res, ok := fpaov.values.([]*PolicySpec_SupportingAlertQuery_LogQuery)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues) AsRestGetQueryArrayOfValues() ([]*PolicySpec_SupportingAlertQuery_RestGetQuery, bool) {
	res, ok := fpaov.values.([]*PolicySpec_SupportingAlertQuery_RestGetQuery)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQuery_FieldTerminalPathArrayOfValues) AsRestListQueryArrayOfValues() ([]*PolicySpec_SupportingAlertQuery_RestListQuery, bool) {
	res, ok := fpaov.values.([]*PolicySpec_SupportingAlertQuery_RestListQuery)
	return res, ok
}

type PolicySpecSupportingAlertQuery_FieldSubPathArrayOfValues struct {
	PolicySpecSupportingAlertQuery_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PolicySpecSupportingAlertQuery_FieldPathArrayOfValues = (*PolicySpecSupportingAlertQuery_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PolicySpecSupportingAlertQuery_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PolicySpecSupportingAlertQuery_FieldSubPathArrayOfValues) AsTsQueryPathArrayOfValues() (PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PolicySpecSupportingAlertQuery_FieldSubPathArrayOfValues) AsLogQueryPathArrayOfValues() (PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PolicySpecSupportingAlertQuery_FieldSubPathArrayOfValues) AsRestGetQueryPathArrayOfValues() (PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PolicySpecSupportingAlertQuery_FieldSubPathArrayOfValues) AsRestListQueryPathArrayOfValues() (PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PolicySpecAIAgentHandling_FieldPathSelector int32

const (
	PolicySpecAIAgentHandling_FieldPathSelectorEnabled               PolicySpecAIAgentHandling_FieldPathSelector = 0
	PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity   PolicySpecAIAgentHandling_FieldPathSelector = 1
	PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation PolicySpecAIAgentHandling_FieldPathSelector = 2
	PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity      PolicySpecAIAgentHandling_FieldPathSelector = 3
	PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions    PolicySpecAIAgentHandling_FieldPathSelector = 4
)

func (s PolicySpecAIAgentHandling_FieldPathSelector) String() string {
	switch s {
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
		return "enabled"
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
		return "enabled_connectivity"
	case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
		return "auto_accept_remediation"
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		return "edge_connectivity"
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		return "remediation_options"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", s))
	}
}

func BuildPolicySpecAIAgentHandling_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecAIAgentHandling_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_AIAgentHandling")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "enabled":
			return &PolicySpecAIAgentHandling_FieldTerminalPath{selector: PolicySpecAIAgentHandling_FieldPathSelectorEnabled}, nil
		case "enabled_connectivity", "enabledConnectivity", "enabled-connectivity":
			return &PolicySpecAIAgentHandling_FieldTerminalPath{selector: PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity}, nil
		case "auto_accept_remediation", "autoAcceptRemediation", "auto-accept-remediation":
			return &PolicySpecAIAgentHandling_FieldTerminalPath{selector: PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation}, nil
		case "edge_connectivity", "edgeConnectivity", "edge-connectivity":
			return &PolicySpecAIAgentHandling_FieldTerminalPath{selector: PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity}, nil
		case "remediation_options", "remediationOptions", "remediation-options":
			return &PolicySpecAIAgentHandling_FieldTerminalPath{selector: PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions}, nil
		}
	} else {
		switch fp[0] {
		case "edge_connectivity", "edgeConnectivity", "edge-connectivity":
			if subpath, err := BuildPolicySpecAIAgentHandlingEdgeConnectivity_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecAIAgentHandling_FieldSubPath{selector: PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity, subPath: subpath}, nil
			}
		case "remediation_options", "remediationOptions", "remediation-options":
			if subpath, err := BuildPolicySpecAIAgentHandlingRemediation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecAIAgentHandling_FieldSubPath{selector: PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_AIAgentHandling", fp)
}

func ParsePolicySpecAIAgentHandling_FieldPath(rawField string) (PolicySpecAIAgentHandling_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecAIAgentHandling_FieldPath(fp)
}

func MustParsePolicySpecAIAgentHandling_FieldPath(rawField string) PolicySpecAIAgentHandling_FieldPath {
	fp, err := ParsePolicySpecAIAgentHandling_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecAIAgentHandling_FieldTerminalPath struct {
	selector PolicySpecAIAgentHandling_FieldPathSelector
}

var _ PolicySpecAIAgentHandling_FieldPath = (*PolicySpecAIAgentHandling_FieldTerminalPath)(nil)

func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) Selector() PolicySpecAIAgentHandling_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_AIAgentHandling
func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) Get(source *PolicySpec_AIAgentHandling) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
			values = append(values, source.Enabled)
		case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
			values = append(values, source.EnabledConnectivity)
		case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
			values = append(values, source.AutoAcceptRemediation)
		case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
			if source.EdgeConnectivity != nil {
				values = append(values, source.EdgeConnectivity)
			}
		case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
			for _, value := range source.GetRemediationOptions() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_AIAgentHandling
func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) GetSingle(source *PolicySpec_AIAgentHandling) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
		return source.GetEnabled(), source != nil
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
		return source.GetEnabledConnectivity(), source != nil
	case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
		return source.GetAutoAcceptRemediation(), source != nil
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		res := source.GetEdgeConnectivity()
		return res, res != nil
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		res := source.GetRemediationOptions()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
		return false
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
		return false
	case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
		return false
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		return (*PolicySpec_AIAgentHandling_EdgeConnectivity)(nil)
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		return ([]*PolicySpec_AIAgentHandling_Remediation)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fp.selector))
	}
}

func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) ClearValue(item *PolicySpec_AIAgentHandling) {
	if item != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
			item.Enabled = false
		case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
			item.EnabledConnectivity = false
		case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
			item.AutoAcceptRemediation = false
		case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
			item.EdgeConnectivity = nil
		case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
			item.RemediationOptions = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_AIAgentHandling))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpecAIAgentHandling_FieldPathSelectorEnabled ||
		fp.selector == PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity ||
		fp.selector == PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation
}

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

func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) WithIValue(value interface{}) PolicySpecAIAgentHandling_FieldPathValue {
	switch fp.selector {
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
		return &PolicySpecAIAgentHandling_FieldTerminalPathValue{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, value: value.(bool)}
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
		return &PolicySpecAIAgentHandling_FieldTerminalPathValue{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, value: value.(bool)}
	case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
		return &PolicySpecAIAgentHandling_FieldTerminalPathValue{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, value: value.(bool)}
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		return &PolicySpecAIAgentHandling_FieldTerminalPathValue{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, value: value.(*PolicySpec_AIAgentHandling_EdgeConnectivity)}
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		return &PolicySpecAIAgentHandling_FieldTerminalPathValue{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, value: value.([]*PolicySpec_AIAgentHandling_Remediation)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fp.selector))
	}
}

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

func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandling_FieldPathArrayOfValues {
	fpaov := &PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandling_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
		return &PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, values: values.([]bool)}
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
		return &PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, values: values.([]bool)}
	case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
		return &PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, values: values.([]bool)}
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		return &PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, values: values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity)}
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		return &PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, values: values.([][]*PolicySpec_AIAgentHandling_Remediation)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PolicySpecAIAgentHandling_FieldTerminalPath) WithIArrayItemValue(value interface{}) PolicySpecAIAgentHandling_FieldPathArrayItemValue {
	switch fp.selector {
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		return &PolicySpecAIAgentHandling_FieldTerminalPathArrayItemValue{PolicySpecAIAgentHandling_FieldTerminalPath: *fp, value: value.(*PolicySpec_AIAgentHandling_Remediation)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fp.selector))
	}
}

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

type PolicySpecAIAgentHandling_FieldSubPath struct {
	selector PolicySpecAIAgentHandling_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PolicySpecAIAgentHandling_FieldPath = (*PolicySpecAIAgentHandling_FieldSubPath)(nil)

func (fps *PolicySpecAIAgentHandling_FieldSubPath) Selector() PolicySpecAIAgentHandling_FieldPathSelector {
	return fps.selector
}
func (fps *PolicySpecAIAgentHandling_FieldSubPath) AsEdgeConnectivitySubPath() (PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath)
	return res, ok
}
func (fps *PolicySpecAIAgentHandling_FieldSubPath) AsRemediationOptionsSubPath() (PolicySpecAIAgentHandlingRemediation_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecAIAgentHandlingRemediation_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *PolicySpecAIAgentHandling_FieldSubPath) ClearValue(item *PolicySpec_AIAgentHandling) {
	if item != nil {
		switch fps.selector {
		case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
			fps.subPath.ClearValueRaw(item.EdgeConnectivity)
		case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
			for _, subItem := range item.RemediationOptions {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fps.selector))
		}
	}
}

func (fps *PolicySpecAIAgentHandling_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PolicySpec_AIAgentHandling))
}

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

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

func (fps *PolicySpecAIAgentHandling_FieldSubPath) WithIValue(value interface{}) PolicySpecAIAgentHandling_FieldPathValue {
	return &PolicySpecAIAgentHandling_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PolicySpecAIAgentHandling_FieldSubPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandling_FieldPathArrayOfValues {
	return &PolicySpecAIAgentHandling_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PolicySpecAIAgentHandling_FieldSubPath) WithIArrayItemValue(value interface{}) PolicySpecAIAgentHandling_FieldPathArrayItemValue {
	return &PolicySpecAIAgentHandling_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PolicySpecAIAgentHandling_FieldPathValue allows storing values for AIAgentHandling fields according to their type
type PolicySpecAIAgentHandling_FieldPathValue interface {
	PolicySpecAIAgentHandling_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_AIAgentHandling)
	CompareWith(*PolicySpec_AIAgentHandling) (cmp int, comparable bool)
}

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

func MustParsePolicySpecAIAgentHandling_FieldPathValue(pathStr, valueStr string) PolicySpecAIAgentHandling_FieldPathValue {
	fpv, err := ParsePolicySpecAIAgentHandling_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecAIAgentHandling_FieldTerminalPathValue struct {
	PolicySpecAIAgentHandling_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandling_FieldPathValue = (*PolicySpecAIAgentHandling_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AIAgentHandling' as interface{}
func (fpv *PolicySpecAIAgentHandling_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecAIAgentHandling_FieldTerminalPathValue) AsEnabledValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandling_FieldTerminalPathValue) AsEnabledConnectivityValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandling_FieldTerminalPathValue) AsAutoAcceptRemediationValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandling_FieldTerminalPathValue) AsEdgeConnectivityValue() (*PolicySpec_AIAgentHandling_EdgeConnectivity, bool) {
	res, ok := fpv.value.(*PolicySpec_AIAgentHandling_EdgeConnectivity)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandling_FieldTerminalPathValue) AsRemediationOptionsValue() ([]*PolicySpec_AIAgentHandling_Remediation, bool) {
	res, ok := fpv.value.([]*PolicySpec_AIAgentHandling_Remediation)
	return res, ok
}

// SetTo stores value for selected field for object AIAgentHandling
func (fpv *PolicySpecAIAgentHandling_FieldTerminalPathValue) SetTo(target **PolicySpec_AIAgentHandling) {
	if *target == nil {
		*target = new(PolicySpec_AIAgentHandling)
	}
	switch fpv.selector {
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
		(*target).Enabled = fpv.value.(bool)
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
		(*target).EnabledConnectivity = fpv.value.(bool)
	case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
		(*target).AutoAcceptRemediation = fpv.value.(bool)
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		(*target).EdgeConnectivity = fpv.value.(*PolicySpec_AIAgentHandling_EdgeConnectivity)
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		(*target).RemediationOptions = fpv.value.([]*PolicySpec_AIAgentHandling_Remediation)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpecAIAgentHandling_FieldTerminalPathValue' with the value under path in 'PolicySpec_AIAgentHandling'.
func (fpv *PolicySpecAIAgentHandling_FieldTerminalPathValue) CompareWith(source *PolicySpec_AIAgentHandling) (int, bool) {
	switch fpv.selector {
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
		leftValue := fpv.value.(bool)
		rightValue := source.GetEnabled()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
		leftValue := fpv.value.(bool)
		rightValue := source.GetEnabledConnectivity()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
		leftValue := fpv.value.(bool)
		rightValue := source.GetAutoAcceptRemediation()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		return 0, false
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fpv.selector))
	}
}

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

type PolicySpecAIAgentHandling_FieldSubPathValue struct {
	PolicySpecAIAgentHandling_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PolicySpecAIAgentHandling_FieldPathValue = (*PolicySpecAIAgentHandling_FieldSubPathValue)(nil)

func (fpvs *PolicySpecAIAgentHandling_FieldSubPathValue) AsEdgeConnectivityPathValue() (PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue)
	return res, ok
}
func (fpvs *PolicySpecAIAgentHandling_FieldSubPathValue) AsRemediationOptionsPathValue() (PolicySpecAIAgentHandlingRemediation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecAIAgentHandlingRemediation_FieldPathValue)
	return res, ok
}

func (fpvs *PolicySpecAIAgentHandling_FieldSubPathValue) SetTo(target **PolicySpec_AIAgentHandling) {
	if *target == nil {
		*target = new(PolicySpec_AIAgentHandling)
	}
	switch fpvs.Selector() {
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue).SetTo(&(*target).EdgeConnectivity)
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PolicySpecAIAgentHandling_FieldSubPathValue) CompareWith(source *PolicySpec_AIAgentHandling) (int, bool) {
	switch fpvs.Selector() {
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		return fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue).CompareWith(source.GetEdgeConnectivity())
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePolicySpecAIAgentHandling_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecAIAgentHandling_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecAIAgentHandling_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecAIAgentHandling_FieldTerminalPathArrayItemValue struct {
	PolicySpecAIAgentHandling_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandling_FieldPathArrayItemValue = (*PolicySpecAIAgentHandling_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object PolicySpec_AIAgentHandling as interface{}
func (fpaiv *PolicySpecAIAgentHandling_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *PolicySpecAIAgentHandling_FieldTerminalPathArrayItemValue) AsRemediationOptionsItemValue() (*PolicySpec_AIAgentHandling_Remediation, bool) {
	res, ok := fpaiv.value.(*PolicySpec_AIAgentHandling_Remediation)
	return res, ok
}

func (fpaiv *PolicySpecAIAgentHandling_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_AIAgentHandling) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'AIAgentHandling'
func (fpaiv *PolicySpecAIAgentHandling_FieldTerminalPathArrayItemValue) ContainsValue(source *PolicySpec_AIAgentHandling) bool {
	slice := fpaiv.PolicySpecAIAgentHandling_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 PolicySpecAIAgentHandling_FieldSubPathArrayItemValue struct {
	PolicySpecAIAgentHandling_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PolicySpecAIAgentHandling_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PolicySpecAIAgentHandling_FieldSubPathArrayItemValue) AsEdgeConnectivityPathItemValue() (PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PolicySpecAIAgentHandling_FieldSubPathArrayItemValue) AsRemediationOptionsPathItemValue() (PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'AIAgentHandling'
func (fpaivs *PolicySpecAIAgentHandling_FieldSubPathArrayItemValue) ContainsValue(source *PolicySpec_AIAgentHandling) bool {
	switch fpaivs.Selector() {
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		return fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayItemValue).ContainsValue(source.GetEdgeConnectivity())
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling: %d", fpaivs.Selector()))
	}
}

// PolicySpecAIAgentHandling_FieldPathArrayOfValues allows storing slice of values for AIAgentHandling fields according to their type
type PolicySpecAIAgentHandling_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecAIAgentHandling_FieldPath
}

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

func MustParsePolicySpecAIAgentHandling_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecAIAgentHandling_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecAIAgentHandling_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues struct {
	PolicySpecAIAgentHandling_FieldTerminalPath
	values interface{}
}

var _ PolicySpecAIAgentHandling_FieldPathArrayOfValues = (*PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabled:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandling_FieldPathSelectorEnabledConnectivity:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandling_FieldPathSelectorAutoAcceptRemediation:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandling_FieldPathSelectorEdgeConnectivity:
		for _, v := range fpaov.values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandling_FieldPathSelectorRemediationOptions:
		for _, v := range fpaov.values.([][]*PolicySpec_AIAgentHandling_Remediation) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues) AsEnabledArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues) AsEnabledConnectivityArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues) AsAutoAcceptRemediationArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues) AsEdgeConnectivityArrayOfValues() ([]*PolicySpec_AIAgentHandling_EdgeConnectivity, bool) {
	res, ok := fpaov.values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandling_FieldTerminalPathArrayOfValues) AsRemediationOptionsArrayOfValues() ([][]*PolicySpec_AIAgentHandling_Remediation, bool) {
	res, ok := fpaov.values.([][]*PolicySpec_AIAgentHandling_Remediation)
	return res, ok
}

type PolicySpecAIAgentHandling_FieldSubPathArrayOfValues struct {
	PolicySpecAIAgentHandling_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PolicySpecAIAgentHandling_FieldPathArrayOfValues = (*PolicySpecAIAgentHandling_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PolicySpecAIAgentHandling_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PolicySpecAIAgentHandling_FieldSubPathArrayOfValues) AsEdgeConnectivityPathArrayOfValues() (PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PolicySpecAIAgentHandling_FieldSubPathArrayOfValues) AsRemediationOptionsPathArrayOfValues() (PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PolicySpecResourceIdentityLabelInfo_FieldPathSelector int32

const (
	PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey               PolicySpecResourceIdentityLabelInfo_FieldPathSelector = 0
	PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts          PolicySpecResourceIdentityLabelInfo_FieldPathSelector = 1
	PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment PolicySpecResourceIdentityLabelInfo_FieldPathSelector = 2
)

func (s PolicySpecResourceIdentityLabelInfo_FieldPathSelector) String() string {
	switch s {
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
		return "key"
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
		return "contexts"
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
		return "mapped_name_segment"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", s))
	}
}

func BuildPolicySpecResourceIdentityLabelInfo_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecResourceIdentityLabelInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_ResourceIdentity_LabelInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "key":
			return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPath{selector: PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey}, nil
		case "contexts":
			return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPath{selector: PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts}, nil
		case "mapped_name_segment", "mappedNameSegment", "mapped-name-segment":
			return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPath{selector: PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_ResourceIdentity_LabelInfo", fp)
}

func ParsePolicySpecResourceIdentityLabelInfo_FieldPath(rawField string) (PolicySpecResourceIdentityLabelInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecResourceIdentityLabelInfo_FieldPath(fp)
}

func MustParsePolicySpecResourceIdentityLabelInfo_FieldPath(rawField string) PolicySpecResourceIdentityLabelInfo_FieldPath {
	fp, err := ParsePolicySpecResourceIdentityLabelInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecResourceIdentityLabelInfo_FieldTerminalPath struct {
	selector PolicySpecResourceIdentityLabelInfo_FieldPathSelector
}

var _ PolicySpecResourceIdentityLabelInfo_FieldPath = (*PolicySpecResourceIdentityLabelInfo_FieldTerminalPath)(nil)

func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) Selector() PolicySpecResourceIdentityLabelInfo_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_ResourceIdentity_LabelInfo
func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) Get(source *PolicySpec_ResourceIdentity_LabelInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
			values = append(values, source.Key)
		case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
			for _, value := range source.GetContexts() {
				values = append(values, value)
			}
		case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
			values = append(values, source.MappedNameSegment)
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_ResourceIdentity_LabelInfo
func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) GetSingle(source *PolicySpec_ResourceIdentity_LabelInfo) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
		return source.GetKey(), source != nil
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
		res := source.GetContexts()
		return res, res != nil
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
		return source.GetMappedNameSegment(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
		return ""
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
		return ([]PolicySpec_ResourceIdentity_LabelInfo_UsageContext)(nil)
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", fp.selector))
	}
}

func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) ClearValue(item *PolicySpec_ResourceIdentity_LabelInfo) {
	if item != nil {
		switch fp.selector {
		case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
			item.Key = ""
		case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
			item.Contexts = nil
		case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
			item.MappedNameSegment = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_ResourceIdentity_LabelInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey ||
		fp.selector == PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts ||
		fp.selector == PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment
}

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

func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) WithIValue(value interface{}) PolicySpecResourceIdentityLabelInfo_FieldPathValue {
	switch fp.selector {
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
		return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue{PolicySpecResourceIdentityLabelInfo_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
		return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue{PolicySpecResourceIdentityLabelInfo_FieldTerminalPath: *fp, value: value.([]PolicySpec_ResourceIdentity_LabelInfo_UsageContext)}
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
		return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue{PolicySpecResourceIdentityLabelInfo_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", fp.selector))
	}
}

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

func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecResourceIdentityLabelInfo_FieldPathArrayOfValues {
	fpaov := &PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues{PolicySpecResourceIdentityLabelInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
		return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues{PolicySpecResourceIdentityLabelInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
		return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues{PolicySpecResourceIdentityLabelInfo_FieldTerminalPath: *fp, values: values.([][]PolicySpec_ResourceIdentity_LabelInfo_UsageContext)}
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
		return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues{PolicySpecResourceIdentityLabelInfo_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PolicySpecResourceIdentityLabelInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) PolicySpecResourceIdentityLabelInfo_FieldPathArrayItemValue {
	switch fp.selector {
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
		return &PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayItemValue{PolicySpecResourceIdentityLabelInfo_FieldTerminalPath: *fp, value: value.(PolicySpec_ResourceIdentity_LabelInfo_UsageContext)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", fp.selector))
	}
}

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

// PolicySpecResourceIdentityLabelInfo_FieldPathValue allows storing values for LabelInfo fields according to their type
type PolicySpecResourceIdentityLabelInfo_FieldPathValue interface {
	PolicySpecResourceIdentityLabelInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_ResourceIdentity_LabelInfo)
	CompareWith(*PolicySpec_ResourceIdentity_LabelInfo) (cmp int, comparable bool)
}

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

func MustParsePolicySpecResourceIdentityLabelInfo_FieldPathValue(pathStr, valueStr string) PolicySpecResourceIdentityLabelInfo_FieldPathValue {
	fpv, err := ParsePolicySpecResourceIdentityLabelInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue struct {
	PolicySpecResourceIdentityLabelInfo_FieldTerminalPath
	value interface{}
}

var _ PolicySpecResourceIdentityLabelInfo_FieldPathValue = (*PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'LabelInfo' as interface{}
func (fpv *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue) AsKeyValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue) AsContextsValue() ([]PolicySpec_ResourceIdentity_LabelInfo_UsageContext, bool) {
	res, ok := fpv.value.([]PolicySpec_ResourceIdentity_LabelInfo_UsageContext)
	return res, ok
}
func (fpv *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue) AsMappedNameSegmentValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object LabelInfo
func (fpv *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue) SetTo(target **PolicySpec_ResourceIdentity_LabelInfo) {
	if *target == nil {
		*target = new(PolicySpec_ResourceIdentity_LabelInfo)
	}
	switch fpv.selector {
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
		(*target).Key = fpv.value.(string)
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
		(*target).Contexts = fpv.value.([]PolicySpec_ResourceIdentity_LabelInfo_UsageContext)
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
		(*target).MappedNameSegment = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue' with the value under path in 'PolicySpec_ResourceIdentity_LabelInfo'.
func (fpv *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathValue) CompareWith(source *PolicySpec_ResourceIdentity_LabelInfo) (int, bool) {
	switch fpv.selector {
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
		leftValue := fpv.value.(string)
		rightValue := source.GetKey()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
		return 0, false
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
		leftValue := fpv.value.(string)
		rightValue := source.GetMappedNameSegment()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_ResourceIdentity_LabelInfo: %d", fpv.selector))
	}
}

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

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

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

func MustParsePolicySpecResourceIdentityLabelInfo_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecResourceIdentityLabelInfo_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecResourceIdentityLabelInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayItemValue struct {
	PolicySpecResourceIdentityLabelInfo_FieldTerminalPath
	value interface{}
}

var _ PolicySpecResourceIdentityLabelInfo_FieldPathArrayItemValue = (*PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object PolicySpec_ResourceIdentity_LabelInfo as interface{}
func (fpaiv *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayItemValue) AsContextsItemValue() (PolicySpec_ResourceIdentity_LabelInfo_UsageContext, bool) {
	res, ok := fpaiv.value.(PolicySpec_ResourceIdentity_LabelInfo_UsageContext)
	return res, ok
}

func (fpaiv *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_ResourceIdentity_LabelInfo) (interface{}, bool) {
	return nil, false
}

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

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

// PolicySpecResourceIdentityLabelInfo_FieldPathArrayOfValues allows storing slice of values for LabelInfo fields according to their type
type PolicySpecResourceIdentityLabelInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecResourceIdentityLabelInfo_FieldPath
}

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

func MustParsePolicySpecResourceIdentityLabelInfo_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecResourceIdentityLabelInfo_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecResourceIdentityLabelInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues struct {
	PolicySpecResourceIdentityLabelInfo_FieldTerminalPath
	values interface{}
}

var _ PolicySpecResourceIdentityLabelInfo_FieldPathArrayOfValues = (*PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorKey:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorContexts:
		for _, v := range fpaov.values.([][]PolicySpec_ResourceIdentity_LabelInfo_UsageContext) {
			values = append(values, v)
		}
	case PolicySpecResourceIdentityLabelInfo_FieldPathSelectorMappedNameSegment:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues) AsKeyArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues) AsContextsArrayOfValues() ([][]PolicySpec_ResourceIdentity_LabelInfo_UsageContext, bool) {
	res, ok := fpaov.values.([][]PolicySpec_ResourceIdentity_LabelInfo_UsageContext)
	return res, ok
}
func (fpaov *PolicySpecResourceIdentityLabelInfo_FieldTerminalPathArrayOfValues) AsMappedNameSegmentArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type PolicySpecSupportingAlertQueryTsQuery_FieldPathSelector int32

const (
	PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription    PolicySpecSupportingAlertQueryTsQuery_FieldPathSelector = 0
	PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate PolicySpecSupportingAlertQueryTsQuery_FieldPathSelector = 1
	PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation    PolicySpecSupportingAlertQueryTsQuery_FieldPathSelector = 2
)

func (s PolicySpecSupportingAlertQueryTsQuery_FieldPathSelector) String() string {
	switch s {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription:
		return "description"
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
		return "filter_template"
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		return "aggregation"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", s))
	}
}

func BuildPolicySpecSupportingAlertQueryTsQuery_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecSupportingAlertQueryTsQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_SupportingAlertQuery_TsQuery")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "description":
			return &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription}, nil
		case "filter_template", "filterTemplate", "filter-template":
			return &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate}, nil
		case "aggregation":
			return &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation}, nil
		}
	} else {
		switch fp[0] {
		case "aggregation":
			if subpath, err := monitoring_common.BuildAggregation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecSupportingAlertQueryTsQuery_FieldSubPath{selector: PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_SupportingAlertQuery_TsQuery", fp)
}

func ParsePolicySpecSupportingAlertQueryTsQuery_FieldPath(rawField string) (PolicySpecSupportingAlertQueryTsQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecSupportingAlertQueryTsQuery_FieldPath(fp)
}

func MustParsePolicySpecSupportingAlertQueryTsQuery_FieldPath(rawField string) PolicySpecSupportingAlertQueryTsQuery_FieldPath {
	fp, err := ParsePolicySpecSupportingAlertQueryTsQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath struct {
	selector PolicySpecSupportingAlertQueryTsQuery_FieldPathSelector
}

var _ PolicySpecSupportingAlertQueryTsQuery_FieldPath = (*PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath)(nil)

func (fp *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath) Selector() PolicySpecSupportingAlertQueryTsQuery_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_SupportingAlertQuery_TsQuery
func (fp *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath) Get(source *PolicySpec_SupportingAlertQuery_TsQuery) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
			values = append(values, source.FilterTemplate)
		case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
			if source.Aggregation != nil {
				values = append(values, source.Aggregation)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_SupportingAlertQuery_TsQuery
func (fp *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath) GetSingle(source *PolicySpec_SupportingAlertQuery_TsQuery) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
		return source.GetFilterTemplate(), source != nil
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		res := source.GetAggregation()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription:
		return ""
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
		return ""
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		return (*monitoring_common.Aggregation)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fp.selector))
	}
}

func (fp *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath) ClearValue(item *PolicySpec_SupportingAlertQuery_TsQuery) {
	if item != nil {
		switch fp.selector {
		case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription:
			item.Description = ""
		case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
			item.FilterTemplate = ""
		case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
			item.Aggregation = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_SupportingAlertQuery_TsQuery))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription ||
		fp.selector == PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate
}

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

func (fp *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath) WithIValue(value interface{}) PolicySpecSupportingAlertQueryTsQuery_FieldPathValue {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription:
		return &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
		return &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		return &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath: *fp, value: value.(*monitoring_common.Aggregation)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fp.selector))
	}
}

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

func (fp *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues {
	fpaov := &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription:
		return &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
		return &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		return &PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath: *fp, values: values.([]*monitoring_common.Aggregation)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type PolicySpecSupportingAlertQueryTsQuery_FieldSubPath struct {
	selector PolicySpecSupportingAlertQueryTsQuery_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PolicySpecSupportingAlertQueryTsQuery_FieldPath = (*PolicySpecSupportingAlertQueryTsQuery_FieldSubPath)(nil)

func (fps *PolicySpecSupportingAlertQueryTsQuery_FieldSubPath) Selector() PolicySpecSupportingAlertQueryTsQuery_FieldPathSelector {
	return fps.selector
}
func (fps *PolicySpecSupportingAlertQueryTsQuery_FieldSubPath) AsAggregationSubPath() (monitoring_common.Aggregation_FieldPath, bool) {
	res, ok := fps.subPath.(monitoring_common.Aggregation_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *PolicySpecSupportingAlertQueryTsQuery_FieldSubPath) ClearValue(item *PolicySpec_SupportingAlertQuery_TsQuery) {
	if item != nil {
		switch fps.selector {
		case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
			fps.subPath.ClearValueRaw(item.Aggregation)
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fps.selector))
		}
	}
}

func (fps *PolicySpecSupportingAlertQueryTsQuery_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PolicySpec_SupportingAlertQuery_TsQuery))
}

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

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

func (fps *PolicySpecSupportingAlertQueryTsQuery_FieldSubPath) WithIValue(value interface{}) PolicySpecSupportingAlertQueryTsQuery_FieldPathValue {
	return &PolicySpecSupportingAlertQueryTsQuery_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PolicySpecSupportingAlertQueryTsQuery_FieldSubPath) WithIArrayOfValues(values interface{}) PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues {
	return &PolicySpecSupportingAlertQueryTsQuery_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PolicySpecSupportingAlertQueryTsQuery_FieldSubPath) WithIArrayItemValue(value interface{}) PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayItemValue {
	return &PolicySpecSupportingAlertQueryTsQuery_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PolicySpecSupportingAlertQueryTsQuery_FieldPathValue allows storing values for TsQuery fields according to their type
type PolicySpecSupportingAlertQueryTsQuery_FieldPathValue interface {
	PolicySpecSupportingAlertQueryTsQuery_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_SupportingAlertQuery_TsQuery)
	CompareWith(*PolicySpec_SupportingAlertQuery_TsQuery) (cmp int, comparable bool)
}

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

func MustParsePolicySpecSupportingAlertQueryTsQuery_FieldPathValue(pathStr, valueStr string) PolicySpecSupportingAlertQueryTsQuery_FieldPathValue {
	fpv, err := ParsePolicySpecSupportingAlertQueryTsQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue struct {
	PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQueryTsQuery_FieldPathValue = (*PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TsQuery' as interface{}
func (fpv *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue) AsFilterTemplateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue) AsAggregationValue() (*monitoring_common.Aggregation, bool) {
	res, ok := fpv.value.(*monitoring_common.Aggregation)
	return res, ok
}

// SetTo stores value for selected field for object TsQuery
func (fpv *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue) SetTo(target **PolicySpec_SupportingAlertQuery_TsQuery) {
	if *target == nil {
		*target = new(PolicySpec_SupportingAlertQuery_TsQuery)
	}
	switch fpv.selector {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
		(*target).FilterTemplate = fpv.value.(string)
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		(*target).Aggregation = fpv.value.(*monitoring_common.Aggregation)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue' with the value under path in 'PolicySpec_SupportingAlertQuery_TsQuery'.
func (fpv *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathValue) CompareWith(source *PolicySpec_SupportingAlertQuery_TsQuery) (int, bool) {
	switch fpv.selector {
	case PolicySpecSupportingAlertQueryTsQuery_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 PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
		leftValue := fpv.value.(string)
		rightValue := source.GetFilterTemplate()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fpv.selector))
	}
}

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

type PolicySpecSupportingAlertQueryTsQuery_FieldSubPathValue struct {
	PolicySpecSupportingAlertQueryTsQuery_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PolicySpecSupportingAlertQueryTsQuery_FieldPathValue = (*PolicySpecSupportingAlertQueryTsQuery_FieldSubPathValue)(nil)

func (fpvs *PolicySpecSupportingAlertQueryTsQuery_FieldSubPathValue) AsAggregationPathValue() (monitoring_common.Aggregation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(monitoring_common.Aggregation_FieldPathValue)
	return res, ok
}

func (fpvs *PolicySpecSupportingAlertQueryTsQuery_FieldSubPathValue) SetTo(target **PolicySpec_SupportingAlertQuery_TsQuery) {
	if *target == nil {
		*target = new(PolicySpec_SupportingAlertQuery_TsQuery)
	}
	switch fpvs.Selector() {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		fpvs.subPathValue.(monitoring_common.Aggregation_FieldPathValue).SetTo(&(*target).Aggregation)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PolicySpecSupportingAlertQueryTsQuery_FieldSubPathValue) CompareWith(source *PolicySpec_SupportingAlertQuery_TsQuery) (int, bool) {
	switch fpvs.Selector() {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		return fpvs.subPathValue.(monitoring_common.Aggregation_FieldPathValue).CompareWith(source.GetAggregation())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePolicySpecSupportingAlertQueryTsQuery_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecSupportingAlertQueryTsQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayItemValue struct {
	PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayItemValue = (*PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_SupportingAlertQuery_TsQuery) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'TsQuery'
func (fpaiv *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayItemValue) ContainsValue(source *PolicySpec_SupportingAlertQuery_TsQuery) bool {
	slice := fpaiv.PolicySpecSupportingAlertQueryTsQuery_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 PolicySpecSupportingAlertQueryTsQuery_FieldSubPathArrayItemValue struct {
	PolicySpecSupportingAlertQueryTsQuery_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'TsQuery'
func (fpaivs *PolicySpecSupportingAlertQueryTsQuery_FieldSubPathArrayItemValue) ContainsValue(source *PolicySpec_SupportingAlertQuery_TsQuery) bool {
	switch fpaivs.Selector() {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		return fpaivs.subPathItemValue.(monitoring_common.Aggregation_FieldPathArrayItemValue).ContainsValue(source.GetAggregation())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_TsQuery: %d", fpaivs.Selector()))
	}
}

// PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues allows storing slice of values for TsQuery fields according to their type
type PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecSupportingAlertQueryTsQuery_FieldPath
}

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

func MustParsePolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues struct {
	PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPath
	values interface{}
}

var _ PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues = (*PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorFilterTemplate:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryTsQuery_FieldPathSelectorAggregation:
		for _, v := range fpaov.values.([]*monitoring_common.Aggregation) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues) AsFilterTemplateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryTsQuery_FieldTerminalPathArrayOfValues) AsAggregationArrayOfValues() ([]*monitoring_common.Aggregation, bool) {
	res, ok := fpaov.values.([]*monitoring_common.Aggregation)
	return res, ok
}

type PolicySpecSupportingAlertQueryTsQuery_FieldSubPathArrayOfValues struct {
	PolicySpecSupportingAlertQueryTsQuery_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PolicySpecSupportingAlertQueryTsQuery_FieldPathArrayOfValues = (*PolicySpecSupportingAlertQueryTsQuery_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PolicySpecSupportingAlertQueryTsQuery_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PolicySpecSupportingAlertQueryTsQuery_FieldSubPathArrayOfValues) AsAggregationPathArrayOfValues() (monitoring_common.Aggregation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(monitoring_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 PolicySpecSupportingAlertQueryLogQuery_FieldPath interface {
	gotenobject.FieldPath
	Selector() PolicySpecSupportingAlertQueryLogQuery_FieldPathSelector
	Get(source *PolicySpec_SupportingAlertQuery_LogQuery) []interface{}
	GetSingle(source *PolicySpec_SupportingAlertQuery_LogQuery) (interface{}, bool)
	ClearValue(item *PolicySpec_SupportingAlertQuery_LogQuery)

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

type PolicySpecSupportingAlertQueryLogQuery_FieldPathSelector int32

const (
	PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription    PolicySpecSupportingAlertQueryLogQuery_FieldPathSelector = 0
	PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate PolicySpecSupportingAlertQueryLogQuery_FieldPathSelector = 1
)

func (s PolicySpecSupportingAlertQueryLogQuery_FieldPathSelector) String() string {
	switch s {
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription:
		return "description"
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate:
		return "filter_template"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_LogQuery: %d", s))
	}
}

func BuildPolicySpecSupportingAlertQueryLogQuery_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecSupportingAlertQueryLogQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_SupportingAlertQuery_LogQuery")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "description":
			return &PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription}, nil
		case "filter_template", "filterTemplate", "filter-template":
			return &PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_SupportingAlertQuery_LogQuery", fp)
}

func ParsePolicySpecSupportingAlertQueryLogQuery_FieldPath(rawField string) (PolicySpecSupportingAlertQueryLogQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecSupportingAlertQueryLogQuery_FieldPath(fp)
}

func MustParsePolicySpecSupportingAlertQueryLogQuery_FieldPath(rawField string) PolicySpecSupportingAlertQueryLogQuery_FieldPath {
	fp, err := ParsePolicySpecSupportingAlertQueryLogQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath struct {
	selector PolicySpecSupportingAlertQueryLogQuery_FieldPathSelector
}

var _ PolicySpecSupportingAlertQueryLogQuery_FieldPath = (*PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath)(nil)

func (fp *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath) Selector() PolicySpecSupportingAlertQueryLogQuery_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source PolicySpec_SupportingAlertQuery_LogQuery
func (fp *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath) GetSingle(source *PolicySpec_SupportingAlertQuery_LogQuery) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate:
		return source.GetFilterTemplate(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_LogQuery: %d", fp.selector))
	}
}

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

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

func (fp *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath) ClearValue(item *PolicySpec_SupportingAlertQuery_LogQuery) {
	if item != nil {
		switch fp.selector {
		case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription:
			item.Description = ""
		case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate:
			item.FilterTemplate = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_LogQuery: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_SupportingAlertQuery_LogQuery))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription ||
		fp.selector == PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate
}

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

func (fp *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath) WithIValue(value interface{}) PolicySpecSupportingAlertQueryLogQuery_FieldPathValue {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription:
		return &PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate:
		return &PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_LogQuery: %d", fp.selector))
	}
}

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

func (fp *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayOfValues {
	fpaov := &PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription:
		return &PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate:
		return &PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_LogQuery: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PolicySpecSupportingAlertQueryLogQuery_FieldPathValue allows storing values for LogQuery fields according to their type
type PolicySpecSupportingAlertQueryLogQuery_FieldPathValue interface {
	PolicySpecSupportingAlertQueryLogQuery_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_SupportingAlertQuery_LogQuery)
	CompareWith(*PolicySpec_SupportingAlertQuery_LogQuery) (cmp int, comparable bool)
}

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

func MustParsePolicySpecSupportingAlertQueryLogQuery_FieldPathValue(pathStr, valueStr string) PolicySpecSupportingAlertQueryLogQuery_FieldPathValue {
	fpv, err := ParsePolicySpecSupportingAlertQueryLogQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue struct {
	PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQueryLogQuery_FieldPathValue = (*PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'LogQuery' as interface{}
func (fpv *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue) AsFilterTemplateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object LogQuery
func (fpv *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue) SetTo(target **PolicySpec_SupportingAlertQuery_LogQuery) {
	if *target == nil {
		*target = new(PolicySpec_SupportingAlertQuery_LogQuery)
	}
	switch fpv.selector {
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate:
		(*target).FilterTemplate = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_LogQuery: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue' with the value under path in 'PolicySpec_SupportingAlertQuery_LogQuery'.
func (fpv *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathValue) CompareWith(source *PolicySpec_SupportingAlertQuery_LogQuery) (int, bool) {
	switch fpv.selector {
	case PolicySpecSupportingAlertQueryLogQuery_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 PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate:
		leftValue := fpv.value.(string)
		rightValue := source.GetFilterTemplate()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_LogQuery: %d", fpv.selector))
	}
}

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

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

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

func MustParsePolicySpecSupportingAlertQueryLogQuery_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecSupportingAlertQueryLogQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayItemValue struct {
	PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayItemValue = (*PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_SupportingAlertQuery_LogQuery) (interface{}, bool) {
	return nil, false
}

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

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

// PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayOfValues allows storing slice of values for LogQuery fields according to their type
type PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecSupportingAlertQueryLogQuery_FieldPath
}

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

func MustParsePolicySpecSupportingAlertQueryLogQuery_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecSupportingAlertQueryLogQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayOfValues struct {
	PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPath
	values interface{}
}

var _ PolicySpecSupportingAlertQueryLogQuery_FieldPathArrayOfValues = (*PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryLogQuery_FieldPathSelectorFilterTemplate:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryLogQuery_FieldTerminalPathArrayOfValues) AsFilterTemplateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelector int32

const (
	PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription  PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelector = 0
	PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint     PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelector = 1
	PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelector = 2
	PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView         PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelector = 3
	PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask    PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelector = 4
)

func (s PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelector) String() string {
	switch s {
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription:
		return "description"
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
		return "endpoint"
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
		return "path_template"
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
		return "view"
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
		return "field_mask"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestGetQuery: %d", s))
	}
}

func BuildPolicySpecSupportingAlertQueryRestGetQuery_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecSupportingAlertQueryRestGetQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_SupportingAlertQuery_RestGetQuery")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "description":
			return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription}, nil
		case "endpoint":
			return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint}, nil
		case "path_template", "pathTemplate", "path-template":
			return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate}, nil
		case "view":
			return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_SupportingAlertQuery_RestGetQuery", fp)
}

func ParsePolicySpecSupportingAlertQueryRestGetQuery_FieldPath(rawField string) (PolicySpecSupportingAlertQueryRestGetQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecSupportingAlertQueryRestGetQuery_FieldPath(fp)
}

func MustParsePolicySpecSupportingAlertQueryRestGetQuery_FieldPath(rawField string) PolicySpecSupportingAlertQueryRestGetQuery_FieldPath {
	fp, err := ParsePolicySpecSupportingAlertQueryRestGetQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath struct {
	selector PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelector
}

var _ PolicySpecSupportingAlertQueryRestGetQuery_FieldPath = (*PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath)(nil)

func (fp *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath) Selector() PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_SupportingAlertQuery_RestGetQuery
func (fp *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath) Get(source *PolicySpec_SupportingAlertQuery_RestGetQuery) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
			values = append(values, source.Endpoint)
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
			values = append(values, source.PathTemplate)
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
			values = append(values, source.View)
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
			values = append(values, source.FieldMask)
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestGetQuery: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_SupportingAlertQuery_RestGetQuery
func (fp *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath) GetSingle(source *PolicySpec_SupportingAlertQuery_RestGetQuery) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
		return source.GetEndpoint(), source != nil
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
		return source.GetPathTemplate(), source != nil
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
		return source.GetView(), source != nil
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
		return source.GetFieldMask(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestGetQuery: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription:
		return ""
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
		return ""
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
		return ""
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
		return ""
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestGetQuery: %d", fp.selector))
	}
}

func (fp *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath) ClearValue(item *PolicySpec_SupportingAlertQuery_RestGetQuery) {
	if item != nil {
		switch fp.selector {
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription:
			item.Description = ""
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
			item.Endpoint = ""
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
			item.PathTemplate = ""
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
			item.View = ""
		case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
			item.FieldMask = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestGetQuery: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_SupportingAlertQuery_RestGetQuery))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription ||
		fp.selector == PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint ||
		fp.selector == PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate ||
		fp.selector == PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView ||
		fp.selector == PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask
}

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

func (fp *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath) WithIValue(value interface{}) PolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestGetQuery: %d", fp.selector))
	}
}

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

func (fp *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayOfValues {
	fpaov := &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
		return &PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestGetQuery: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue allows storing values for RestGetQuery fields according to their type
type PolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue interface {
	PolicySpecSupportingAlertQueryRestGetQuery_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_SupportingAlertQuery_RestGetQuery)
	CompareWith(*PolicySpec_SupportingAlertQuery_RestGetQuery) (cmp int, comparable bool)
}

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

func MustParsePolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue(pathStr, valueStr string) PolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue {
	fpv, err := ParsePolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue struct {
	PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQueryRestGetQuery_FieldPathValue = (*PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RestGetQuery' as interface{}
func (fpv *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue) AsEndpointValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue) AsPathTemplateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue) AsViewValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue) AsFieldMaskValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object RestGetQuery
func (fpv *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue) SetTo(target **PolicySpec_SupportingAlertQuery_RestGetQuery) {
	if *target == nil {
		*target = new(PolicySpec_SupportingAlertQuery_RestGetQuery)
	}
	switch fpv.selector {
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
		(*target).Endpoint = fpv.value.(string)
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
		(*target).PathTemplate = fpv.value.(string)
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
		(*target).View = fpv.value.(string)
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestGetQuery: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue' with the value under path in 'PolicySpec_SupportingAlertQuery_RestGetQuery'.
func (fpv *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathValue) CompareWith(source *PolicySpec_SupportingAlertQuery_RestGetQuery) (int, bool) {
	switch fpv.selector {
	case PolicySpecSupportingAlertQueryRestGetQuery_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 PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
		leftValue := fpv.value.(string)
		rightValue := source.GetEndpoint()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
		leftValue := fpv.value.(string)
		rightValue := source.GetPathTemplate()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
		leftValue := fpv.value.(string)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
		leftValue := fpv.value.(string)
		rightValue := source.GetFieldMask()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestGetQuery: %d", fpv.selector))
	}
}

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

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

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

func MustParsePolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayItemValue struct {
	PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayItemValue = (*PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_SupportingAlertQuery_RestGetQuery) (interface{}, bool) {
	return nil, false
}

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

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

// PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayOfValues allows storing slice of values for RestGetQuery fields according to their type
type PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecSupportingAlertQueryRestGetQuery_FieldPath
}

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

func MustParsePolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues struct {
	PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPath
	values interface{}
}

var _ PolicySpecSupportingAlertQueryRestGetQuery_FieldPathArrayOfValues = (*PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorEndpoint:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorPathTemplate:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorView:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryRestGetQuery_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues) AsEndpointArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues) AsPathTemplateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryRestGetQuery_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector int32

const (
	PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription    PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector = 0
	PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint       PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector = 1
	PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate   PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector = 2
	PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView           PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector = 3
	PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask      PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector = 4
	PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector = 5
)

func (s PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector) String() string {
	switch s {
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription:
		return "description"
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
		return "endpoint"
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
		return "path_template"
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
		return "view"
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
		return "field_mask"
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
		return "filter_template"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestListQuery: %d", s))
	}
}

func BuildPolicySpecSupportingAlertQueryRestListQuery_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecSupportingAlertQueryRestListQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_SupportingAlertQuery_RestListQuery")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "description":
			return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription}, nil
		case "endpoint":
			return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint}, nil
		case "path_template", "pathTemplate", "path-template":
			return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate}, nil
		case "view":
			return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask}, nil
		case "filter_template", "filterTemplate", "filter-template":
			return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath{selector: PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_SupportingAlertQuery_RestListQuery", fp)
}

func ParsePolicySpecSupportingAlertQueryRestListQuery_FieldPath(rawField string) (PolicySpecSupportingAlertQueryRestListQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecSupportingAlertQueryRestListQuery_FieldPath(fp)
}

func MustParsePolicySpecSupportingAlertQueryRestListQuery_FieldPath(rawField string) PolicySpecSupportingAlertQueryRestListQuery_FieldPath {
	fp, err := ParsePolicySpecSupportingAlertQueryRestListQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath struct {
	selector PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector
}

var _ PolicySpecSupportingAlertQueryRestListQuery_FieldPath = (*PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath)(nil)

func (fp *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath) Selector() PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_SupportingAlertQuery_RestListQuery
func (fp *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath) Get(source *PolicySpec_SupportingAlertQuery_RestListQuery) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
			values = append(values, source.Endpoint)
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
			values = append(values, source.PathTemplate)
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
			values = append(values, source.View)
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
			values = append(values, source.FieldMask)
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
			values = append(values, source.FilterTemplate)
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestListQuery: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_SupportingAlertQuery_RestListQuery
func (fp *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath) GetSingle(source *PolicySpec_SupportingAlertQuery_RestListQuery) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
		return source.GetEndpoint(), source != nil
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
		return source.GetPathTemplate(), source != nil
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
		return source.GetView(), source != nil
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
		return source.GetFieldMask(), source != nil
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
		return source.GetFilterTemplate(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestListQuery: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription:
		return ""
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
		return ""
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
		return ""
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
		return ""
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
		return ""
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestListQuery: %d", fp.selector))
	}
}

func (fp *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath) ClearValue(item *PolicySpec_SupportingAlertQuery_RestListQuery) {
	if item != nil {
		switch fp.selector {
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription:
			item.Description = ""
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
			item.Endpoint = ""
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
			item.PathTemplate = ""
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
			item.View = ""
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
			item.FieldMask = ""
		case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
			item.FilterTemplate = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestListQuery: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_SupportingAlertQuery_RestListQuery))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription ||
		fp.selector == PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint ||
		fp.selector == PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate ||
		fp.selector == PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView ||
		fp.selector == PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask ||
		fp.selector == PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate
}

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

func (fp *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath) WithIValue(value interface{}) PolicySpecSupportingAlertQueryRestListQuery_FieldPathValue {
	switch fp.selector {
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestListQuery: %d", fp.selector))
	}
}

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

func (fp *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayOfValues {
	fpaov := &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
		return &PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues{PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestListQuery: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PolicySpecSupportingAlertQueryRestListQuery_FieldPathValue allows storing values for RestListQuery fields according to their type
type PolicySpecSupportingAlertQueryRestListQuery_FieldPathValue interface {
	PolicySpecSupportingAlertQueryRestListQuery_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_SupportingAlertQuery_RestListQuery)
	CompareWith(*PolicySpec_SupportingAlertQuery_RestListQuery) (cmp int, comparable bool)
}

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

func MustParsePolicySpecSupportingAlertQueryRestListQuery_FieldPathValue(pathStr, valueStr string) PolicySpecSupportingAlertQueryRestListQuery_FieldPathValue {
	fpv, err := ParsePolicySpecSupportingAlertQueryRestListQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue struct {
	PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQueryRestListQuery_FieldPathValue = (*PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RestListQuery' as interface{}
func (fpv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue) AsEndpointValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue) AsPathTemplateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue) AsViewValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue) AsFieldMaskValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue) AsFilterTemplateValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object RestListQuery
func (fpv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue) SetTo(target **PolicySpec_SupportingAlertQuery_RestListQuery) {
	if *target == nil {
		*target = new(PolicySpec_SupportingAlertQuery_RestListQuery)
	}
	switch fpv.selector {
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
		(*target).Endpoint = fpv.value.(string)
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
		(*target).PathTemplate = fpv.value.(string)
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
		(*target).View = fpv.value.(string)
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(string)
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
		(*target).FilterTemplate = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestListQuery: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue' with the value under path in 'PolicySpec_SupportingAlertQuery_RestListQuery'.
func (fpv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathValue) CompareWith(source *PolicySpec_SupportingAlertQuery_RestListQuery) (int, bool) {
	switch fpv.selector {
	case PolicySpecSupportingAlertQueryRestListQuery_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 PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
		leftValue := fpv.value.(string)
		rightValue := source.GetEndpoint()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
		leftValue := fpv.value.(string)
		rightValue := source.GetPathTemplate()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
		leftValue := fpv.value.(string)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
		leftValue := fpv.value.(string)
		rightValue := source.GetFieldMask()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
		leftValue := fpv.value.(string)
		rightValue := source.GetFilterTemplate()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_SupportingAlertQuery_RestListQuery: %d", fpv.selector))
	}
}

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

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

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

func MustParsePolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayItemValue struct {
	PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath
	value interface{}
}

var _ PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayItemValue = (*PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_SupportingAlertQuery_RestListQuery) (interface{}, bool) {
	return nil, false
}

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

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

// PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayOfValues allows storing slice of values for RestListQuery fields according to their type
type PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecSupportingAlertQueryRestListQuery_FieldPath
}

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

func MustParsePolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues struct {
	PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPath
	values interface{}
}

var _ PolicySpecSupportingAlertQueryRestListQuery_FieldPathArrayOfValues = (*PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorEndpoint:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorPathTemplate:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorView:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecSupportingAlertQueryRestListQuery_FieldPathSelectorFilterTemplate:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues) AsEndpointArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues) AsPathTemplateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecSupportingAlertQueryRestListQuery_FieldTerminalPathArrayOfValues) AsFilterTemplateArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector int32

const (
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh   PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector = 0
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh  PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector = 1
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh      PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector = 2
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector = 3
)

func (s PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector) String() string {
	switch s {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		return "device_ssh"
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		return "proxies_ssh"
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		return "pod_ssh"
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
		return "allowed_bins"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", s))
	}
}

func BuildPolicySpecAIAgentHandlingEdgeConnectivity_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_AIAgentHandling_EdgeConnectivity")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "device_ssh", "deviceSsh", "device-ssh":
			return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh}, nil
		case "proxies_ssh", "proxiesSsh", "proxies-ssh":
			return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh}, nil
		case "pod_ssh", "podSsh", "pod-ssh":
			return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh}, nil
		case "allowed_bins", "allowedBins", "allowed-bins":
			return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins}, nil
		}
	} else {
		switch fp[0] {
		case "device_ssh", "deviceSsh", "device-ssh":
			if subpath, err := BuildPolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath{selector: PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh, subPath: subpath}, nil
			}
		case "proxies_ssh", "proxiesSsh", "proxies-ssh":
			if subpath, err := BuildPolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath{selector: PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh, subPath: subpath}, nil
			}
		case "pod_ssh", "podSsh", "pod-ssh":
			if subpath, err := BuildPolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath{selector: PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_AIAgentHandling_EdgeConnectivity", fp)
}

func ParsePolicySpecAIAgentHandlingEdgeConnectivity_FieldPath(rawField string) (PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecAIAgentHandlingEdgeConnectivity_FieldPath(fp)
}

func MustParsePolicySpecAIAgentHandlingEdgeConnectivity_FieldPath(rawField string) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath {
	fp, err := ParsePolicySpecAIAgentHandlingEdgeConnectivity_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath struct {
	selector PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector
}

var _ PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath = (*PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath)(nil)

func (fp *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath) Selector() PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_AIAgentHandling_EdgeConnectivity
func (fp *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath) Get(source *PolicySpec_AIAgentHandling_EdgeConnectivity) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
			if source, ok := source.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh); ok && source != nil {
				if source.DeviceSsh != nil {
					values = append(values, source.DeviceSsh)
				}
			}
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
			if source, ok := source.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh); ok && source != nil {
				if source.ProxiesSsh != nil {
					values = append(values, source.ProxiesSsh)
				}
			}
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
			if source, ok := source.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh); ok && source != nil {
				if source.PodSsh != nil {
					values = append(values, source.PodSsh)
				}
			}
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
			for _, value := range source.GetAllowedBins() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_AIAgentHandling_EdgeConnectivity
func (fp *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath) GetSingle(source *PolicySpec_AIAgentHandling_EdgeConnectivity) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetDeviceSsh(), false
		}
		_, oneOfSelected := source.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh)
		if !oneOfSelected {
			return source.GetDeviceSsh(), false // to return "type" information
		}
		res := source.GetDeviceSsh()
		return res, res != nil
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetProxiesSsh(), false
		}
		_, oneOfSelected := source.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh)
		if !oneOfSelected {
			return source.GetProxiesSsh(), false // to return "type" information
		}
		res := source.GetProxiesSsh()
		return res, res != nil
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetPodSsh(), false
		}
		_, oneOfSelected := source.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh)
		if !oneOfSelected {
			return source.GetPodSsh(), false // to return "type" information
		}
		res := source.GetPodSsh()
		return res, res != nil
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
		res := source.GetAllowedBins()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		return (*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH)(nil)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		return (*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH)(nil)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		return (*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH)(nil)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
		return ([]string)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fp.selector))
	}
}

func (fp *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath) ClearValue(item *PolicySpec_AIAgentHandling_EdgeConnectivity) {
	if item != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
			if item, ok := item.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh); ok {
				item.DeviceSsh = nil
			}
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
			if item, ok := item.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh); ok {
				item.ProxiesSsh = nil
			}
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
			if item, ok := item.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh); ok {
				item.PodSsh = nil
			}
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
			item.AllowedBins = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_AIAgentHandling_EdgeConnectivity))
}

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

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath) WithIValue(value interface{}) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp, value: value.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH)}
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp, value: value.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH)}
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp, value: value.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH)}
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
		return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fp.selector))
	}
}

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues {
	fpaov := &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp, values: values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH)}
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp, values: values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH)}
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp, values: values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH)}
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
		return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath) WithIArrayItemValue(value interface{}) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayItemValue {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
		return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayItemValue{PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fp.selector))
	}
}

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

type PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath struct {
	selector PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath = (*PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath)(nil)

func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) Selector() PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelector {
	return fps.selector
}
func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) AsDeviceSshSubPath() (PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath)
	return res, ok
}
func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) AsProxiesSshSubPath() (PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath)
	return res, ok
}
func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) AsPodSshSubPath() (PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source PolicySpec_AIAgentHandling_EdgeConnectivity
func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) Get(source *PolicySpec_AIAgentHandling_EdgeConnectivity) (values []interface{}) {
	switch fps.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		values = append(values, fps.subPath.GetRaw(source.GetDeviceSsh())...)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		values = append(values, fps.subPath.GetRaw(source.GetProxiesSsh())...)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		values = append(values, fps.subPath.GetRaw(source.GetPodSsh())...)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source PolicySpec_AIAgentHandling_EdgeConnectivity
func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) GetSingle(source *PolicySpec_AIAgentHandling_EdgeConnectivity) (interface{}, bool) {
	switch fps.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		if source.GetDeviceSsh() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetDeviceSsh())
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		if source.GetProxiesSsh() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetProxiesSsh())
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		if source.GetPodSsh() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetPodSsh())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fps.selector))
	}
}

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

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

func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) ClearValue(item *PolicySpec_AIAgentHandling_EdgeConnectivity) {
	if item != nil {
		switch fps.selector {
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
			if item.Type != nil {
				if item, ok := item.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh); ok {
					fps.subPath.ClearValueRaw(item.DeviceSsh)
				}
			}
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
			if item.Type != nil {
				if item, ok := item.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh); ok {
					fps.subPath.ClearValueRaw(item.ProxiesSsh)
				}
			}
		case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
			if item.Type != nil {
				if item, ok := item.Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh); ok {
					fps.subPath.ClearValueRaw(item.PodSsh)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fps.selector))
		}
	}
}

func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PolicySpec_AIAgentHandling_EdgeConnectivity))
}

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

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

func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) WithIValue(value interface{}) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue {
	return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues {
	return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPath) WithIArrayItemValue(value interface{}) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayItemValue {
	return &PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue allows storing values for EdgeConnectivity fields according to their type
type PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue interface {
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_AIAgentHandling_EdgeConnectivity)
	CompareWith(*PolicySpec_AIAgentHandling_EdgeConnectivity) (cmp int, comparable bool)
}

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue(pathStr, valueStr string) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue {
	fpv, err := ParsePolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue = (*PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'EdgeConnectivity' as interface{}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue) AsDeviceSshValue() (*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH, bool) {
	res, ok := fpv.value.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue) AsProxiesSshValue() (*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH, bool) {
	res, ok := fpv.value.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue) AsPodSshValue() (*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH, bool) {
	res, ok := fpv.value.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue) AsAllowedBinsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object EdgeConnectivity
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathValue) SetTo(target **PolicySpec_AIAgentHandling_EdgeConnectivity) {
	if *target == nil {
		*target = new(PolicySpec_AIAgentHandling_EdgeConnectivity)
	}
	switch fpv.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh{}
		}
		(*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh).DeviceSsh = fpv.value.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh{}
		}
		(*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh).ProxiesSsh = fpv.value.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh{}
		}
		(*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh).PodSsh = fpv.value.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
		(*target).AllowedBins = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fpv.selector))
	}
}

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

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

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

type PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathValue = (*PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathValue)(nil)

func (fpvs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathValue) AsDeviceSshPathValue() (PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue)
	return res, ok
}
func (fpvs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathValue) AsProxiesSshPathValue() (PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue)
	return res, ok
}
func (fpvs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathValue) AsPodSshPathValue() (PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue)
	return res, ok
}

func (fpvs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathValue) SetTo(target **PolicySpec_AIAgentHandling_EdgeConnectivity) {
	if *target == nil {
		*target = new(PolicySpec_AIAgentHandling_EdgeConnectivity)
	}
	switch fpvs.Selector() {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh{}
		}
		fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue).SetTo(&(*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSsh).DeviceSsh)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh{}
		}
		fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue).SetTo(&(*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSsh).ProxiesSsh)
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh{}
		}
		fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue).SetTo(&(*target).Type.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSsh).PodSsh)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathValue) CompareWith(source *PolicySpec_AIAgentHandling_EdgeConnectivity) (int, bool) {
	switch fpvs.Selector() {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		return fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue).CompareWith(source.GetDeviceSsh())
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		return fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue).CompareWith(source.GetProxiesSsh())
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		return fpvs.subPathValue.(PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue).CompareWith(source.GetPodSsh())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayItemValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayItemValue = (*PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_AIAgentHandling_EdgeConnectivity) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'EdgeConnectivity'
func (fpaiv *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayItemValue) ContainsValue(source *PolicySpec_AIAgentHandling_EdgeConnectivity) bool {
	slice := fpaiv.PolicySpecAIAgentHandlingEdgeConnectivity_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 PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayItemValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayItemValue) AsDeviceSshPathItemValue() (PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayItemValue) AsProxiesSshPathItemValue() (PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayItemValue) AsPodSshPathItemValue() (PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'EdgeConnectivity'
func (fpaivs *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayItemValue) ContainsValue(source *PolicySpec_AIAgentHandling_EdgeConnectivity) bool {
	switch fpaivs.Selector() {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		return fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayItemValue).ContainsValue(source.GetDeviceSsh())
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		return fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayItemValue).ContainsValue(source.GetProxiesSsh())
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		return fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayItemValue).ContainsValue(source.GetPodSsh())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity: %d", fpaivs.Selector()))
	}
}

// PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues allows storing slice of values for EdgeConnectivity fields according to their type
type PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath
}

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues struct {
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPath
	values interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues = (*PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorDeviceSsh:
		for _, v := range fpaov.values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorProxiesSsh:
		for _, v := range fpaov.values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorPodSsh:
		for _, v := range fpaov.values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathSelectorAllowedBins:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues) AsDeviceSshArrayOfValues() ([]*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH, bool) {
	res, ok := fpaov.values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues) AsProxiesSshArrayOfValues() ([]*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH, bool) {
	res, ok := fpaov.values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues) AsPodSshArrayOfValues() ([]*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH, bool) {
	res, ok := fpaov.values.([]*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivity_FieldTerminalPathArrayOfValues) AsAllowedBinsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}

type PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayOfValues struct {
	PolicySpecAIAgentHandlingEdgeConnectivity_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PolicySpecAIAgentHandlingEdgeConnectivity_FieldPathArrayOfValues = (*PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayOfValues) AsDeviceSshPathArrayOfValues() (PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayOfValues) AsProxiesSshPathArrayOfValues() (PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PolicySpecAIAgentHandlingEdgeConnectivity_FieldSubPathArrayOfValues) AsPodSshPathArrayOfValues() (PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PolicySpecAIAgentHandlingRemediation_FieldPathSelector int32

const (
	PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh PolicySpecAIAgentHandlingRemediation_FieldPathSelector = 0
	PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot   PolicySpecAIAgentHandlingRemediation_FieldPathSelector = 1
)

func (s PolicySpecAIAgentHandlingRemediation_FieldPathSelector) String() string {
	switch s {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		return "fix_in_ssh"
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		return "reboot"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", s))
	}
}

func BuildPolicySpecAIAgentHandlingRemediation_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecAIAgentHandlingRemediation_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_AIAgentHandling_Remediation")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "fix_in_ssh", "fixInSsh", "fix-in-ssh":
			return &PolicySpecAIAgentHandlingRemediation_FieldTerminalPath{selector: PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh}, nil
		case "reboot":
			return &PolicySpecAIAgentHandlingRemediation_FieldTerminalPath{selector: PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot}, nil
		}
	} else {
		switch fp[0] {
		case "fix_in_ssh", "fixInSsh", "fix-in-ssh":
			if subpath, err := BuildPolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecAIAgentHandlingRemediation_FieldSubPath{selector: PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh, subPath: subpath}, nil
			}
		case "reboot":
			if subpath, err := BuildPolicySpecAIAgentHandlingRemediationReboot_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PolicySpecAIAgentHandlingRemediation_FieldSubPath{selector: PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_AIAgentHandling_Remediation", fp)
}

func ParsePolicySpecAIAgentHandlingRemediation_FieldPath(rawField string) (PolicySpecAIAgentHandlingRemediation_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecAIAgentHandlingRemediation_FieldPath(fp)
}

func MustParsePolicySpecAIAgentHandlingRemediation_FieldPath(rawField string) PolicySpecAIAgentHandlingRemediation_FieldPath {
	fp, err := ParsePolicySpecAIAgentHandlingRemediation_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecAIAgentHandlingRemediation_FieldTerminalPath struct {
	selector PolicySpecAIAgentHandlingRemediation_FieldPathSelector
}

var _ PolicySpecAIAgentHandlingRemediation_FieldPath = (*PolicySpecAIAgentHandlingRemediation_FieldTerminalPath)(nil)

func (fp *PolicySpecAIAgentHandlingRemediation_FieldTerminalPath) Selector() PolicySpecAIAgentHandlingRemediation_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_AIAgentHandling_Remediation
func (fp *PolicySpecAIAgentHandlingRemediation_FieldTerminalPath) Get(source *PolicySpec_AIAgentHandling_Remediation) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
			if source, ok := source.Type.(*PolicySpec_AIAgentHandling_Remediation_FixInSsh); ok && source != nil {
				if source.FixInSsh != nil {
					values = append(values, source.FixInSsh)
				}
			}
		case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
			if source, ok := source.Type.(*PolicySpec_AIAgentHandling_Remediation_Reboot_); ok && source != nil {
				if source.Reboot != nil {
					values = append(values, source.Reboot)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_AIAgentHandling_Remediation
func (fp *PolicySpecAIAgentHandlingRemediation_FieldTerminalPath) GetSingle(source *PolicySpec_AIAgentHandling_Remediation) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetFixInSsh(), false
		}
		_, oneOfSelected := source.Type.(*PolicySpec_AIAgentHandling_Remediation_FixInSsh)
		if !oneOfSelected {
			return source.GetFixInSsh(), false // to return "type" information
		}
		res := source.GetFixInSsh()
		return res, res != nil
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetReboot(), false
		}
		_, oneOfSelected := source.Type.(*PolicySpec_AIAgentHandling_Remediation_Reboot_)
		if !oneOfSelected {
			return source.GetReboot(), false // to return "type" information
		}
		res := source.GetReboot()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecAIAgentHandlingRemediation_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		return (*PolicySpec_AIAgentHandling_Remediation_FixInSSH)(nil)
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		return (*PolicySpec_AIAgentHandling_Remediation_Reboot)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fp.selector))
	}
}

func (fp *PolicySpecAIAgentHandlingRemediation_FieldTerminalPath) ClearValue(item *PolicySpec_AIAgentHandling_Remediation) {
	if item != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
			if item, ok := item.Type.(*PolicySpec_AIAgentHandling_Remediation_FixInSsh); ok {
				item.FixInSsh = nil
			}
		case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
			if item, ok := item.Type.(*PolicySpec_AIAgentHandling_Remediation_Reboot_); ok {
				item.Reboot = nil
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecAIAgentHandlingRemediation_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_AIAgentHandling_Remediation))
}

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

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

func (fp *PolicySpecAIAgentHandlingRemediation_FieldTerminalPath) WithIValue(value interface{}) PolicySpecAIAgentHandlingRemediation_FieldPathValue {
	switch fp.selector {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		return &PolicySpecAIAgentHandlingRemediation_FieldTerminalPathValue{PolicySpecAIAgentHandlingRemediation_FieldTerminalPath: *fp, value: value.(*PolicySpec_AIAgentHandling_Remediation_FixInSSH)}
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		return &PolicySpecAIAgentHandlingRemediation_FieldTerminalPathValue{PolicySpecAIAgentHandlingRemediation_FieldTerminalPath: *fp, value: value.(*PolicySpec_AIAgentHandling_Remediation_Reboot)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fp.selector))
	}
}

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

func (fp *PolicySpecAIAgentHandlingRemediation_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues {
	fpaov := &PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingRemediation_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		return &PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingRemediation_FieldTerminalPath: *fp, values: values.([]*PolicySpec_AIAgentHandling_Remediation_FixInSSH)}
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		return &PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingRemediation_FieldTerminalPath: *fp, values: values.([]*PolicySpec_AIAgentHandling_Remediation_Reboot)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type PolicySpecAIAgentHandlingRemediation_FieldSubPath struct {
	selector PolicySpecAIAgentHandlingRemediation_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PolicySpecAIAgentHandlingRemediation_FieldPath = (*PolicySpecAIAgentHandlingRemediation_FieldSubPath)(nil)

func (fps *PolicySpecAIAgentHandlingRemediation_FieldSubPath) Selector() PolicySpecAIAgentHandlingRemediation_FieldPathSelector {
	return fps.selector
}
func (fps *PolicySpecAIAgentHandlingRemediation_FieldSubPath) AsFixInSshSubPath() (PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath)
	return res, ok
}
func (fps *PolicySpecAIAgentHandlingRemediation_FieldSubPath) AsRebootSubPath() (PolicySpecAIAgentHandlingRemediationReboot_FieldPath, bool) {
	res, ok := fps.subPath.(PolicySpecAIAgentHandlingRemediationReboot_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *PolicySpecAIAgentHandlingRemediation_FieldSubPath) ClearValue(item *PolicySpec_AIAgentHandling_Remediation) {
	if item != nil {
		switch fps.selector {
		case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
			if item.Type != nil {
				if item, ok := item.Type.(*PolicySpec_AIAgentHandling_Remediation_FixInSsh); ok {
					fps.subPath.ClearValueRaw(item.FixInSsh)
				}
			}
		case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
			if item.Type != nil {
				if item, ok := item.Type.(*PolicySpec_AIAgentHandling_Remediation_Reboot_); ok {
					fps.subPath.ClearValueRaw(item.Reboot)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fps.selector))
		}
	}
}

func (fps *PolicySpecAIAgentHandlingRemediation_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PolicySpec_AIAgentHandling_Remediation))
}

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

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

func (fps *PolicySpecAIAgentHandlingRemediation_FieldSubPath) WithIValue(value interface{}) PolicySpecAIAgentHandlingRemediation_FieldPathValue {
	return &PolicySpecAIAgentHandlingRemediation_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PolicySpecAIAgentHandlingRemediation_FieldSubPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues {
	return &PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PolicySpecAIAgentHandlingRemediation_FieldSubPath) WithIArrayItemValue(value interface{}) PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue {
	return &PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PolicySpecAIAgentHandlingRemediation_FieldPathValue allows storing values for Remediation fields according to their type
type PolicySpecAIAgentHandlingRemediation_FieldPathValue interface {
	PolicySpecAIAgentHandlingRemediation_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_AIAgentHandling_Remediation)
	CompareWith(*PolicySpec_AIAgentHandling_Remediation) (cmp int, comparable bool)
}

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

func MustParsePolicySpecAIAgentHandlingRemediation_FieldPathValue(pathStr, valueStr string) PolicySpecAIAgentHandlingRemediation_FieldPathValue {
	fpv, err := ParsePolicySpecAIAgentHandlingRemediation_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecAIAgentHandlingRemediation_FieldTerminalPathValue struct {
	PolicySpecAIAgentHandlingRemediation_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingRemediation_FieldPathValue = (*PolicySpecAIAgentHandlingRemediation_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Remediation' as interface{}
func (fpv *PolicySpecAIAgentHandlingRemediation_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecAIAgentHandlingRemediation_FieldTerminalPathValue) AsFixInSshValue() (*PolicySpec_AIAgentHandling_Remediation_FixInSSH, bool) {
	res, ok := fpv.value.(*PolicySpec_AIAgentHandling_Remediation_FixInSSH)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandlingRemediation_FieldTerminalPathValue) AsRebootValue() (*PolicySpec_AIAgentHandling_Remediation_Reboot, bool) {
	res, ok := fpv.value.(*PolicySpec_AIAgentHandling_Remediation_Reboot)
	return res, ok
}

// SetTo stores value for selected field for object Remediation
func (fpv *PolicySpecAIAgentHandlingRemediation_FieldTerminalPathValue) SetTo(target **PolicySpec_AIAgentHandling_Remediation) {
	if *target == nil {
		*target = new(PolicySpec_AIAgentHandling_Remediation)
	}
	switch fpv.selector {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_Remediation_FixInSsh); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_Remediation_FixInSsh{}
		}
		(*target).Type.(*PolicySpec_AIAgentHandling_Remediation_FixInSsh).FixInSsh = fpv.value.(*PolicySpec_AIAgentHandling_Remediation_FixInSSH)
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_Remediation_Reboot_); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_Remediation_Reboot_{}
		}
		(*target).Type.(*PolicySpec_AIAgentHandling_Remediation_Reboot_).Reboot = fpv.value.(*PolicySpec_AIAgentHandling_Remediation_Reboot)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fpv.selector))
	}
}

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

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

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

type PolicySpecAIAgentHandlingRemediation_FieldSubPathValue struct {
	PolicySpecAIAgentHandlingRemediation_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PolicySpecAIAgentHandlingRemediation_FieldPathValue = (*PolicySpecAIAgentHandlingRemediation_FieldSubPathValue)(nil)

func (fpvs *PolicySpecAIAgentHandlingRemediation_FieldSubPathValue) AsFixInSshPathValue() (PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue)
	return res, ok
}
func (fpvs *PolicySpecAIAgentHandlingRemediation_FieldSubPathValue) AsRebootPathValue() (PolicySpecAIAgentHandlingRemediationReboot_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PolicySpecAIAgentHandlingRemediationReboot_FieldPathValue)
	return res, ok
}

func (fpvs *PolicySpecAIAgentHandlingRemediation_FieldSubPathValue) SetTo(target **PolicySpec_AIAgentHandling_Remediation) {
	if *target == nil {
		*target = new(PolicySpec_AIAgentHandling_Remediation)
	}
	switch fpvs.Selector() {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_Remediation_FixInSsh); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_Remediation_FixInSsh{}
		}
		fpvs.subPathValue.(PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue).SetTo(&(*target).Type.(*PolicySpec_AIAgentHandling_Remediation_FixInSsh).FixInSsh)
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		if _, ok := (*target).Type.(*PolicySpec_AIAgentHandling_Remediation_Reboot_); !ok {
			(*target).Type = &PolicySpec_AIAgentHandling_Remediation_Reboot_{}
		}
		fpvs.subPathValue.(PolicySpecAIAgentHandlingRemediationReboot_FieldPathValue).SetTo(&(*target).Type.(*PolicySpec_AIAgentHandling_Remediation_Reboot_).Reboot)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PolicySpecAIAgentHandlingRemediation_FieldSubPathValue) CompareWith(source *PolicySpec_AIAgentHandling_Remediation) (int, bool) {
	switch fpvs.Selector() {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		return fpvs.subPathValue.(PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue).CompareWith(source.GetFixInSsh())
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		return fpvs.subPathValue.(PolicySpecAIAgentHandlingRemediationReboot_FieldPathValue).CompareWith(source.GetReboot())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayItemValue struct {
	PolicySpecAIAgentHandlingRemediation_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue = (*PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_AIAgentHandling_Remediation) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Remediation'
func (fpaiv *PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayItemValue) ContainsValue(source *PolicySpec_AIAgentHandling_Remediation) bool {
	slice := fpaiv.PolicySpecAIAgentHandlingRemediation_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 PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayItemValue struct {
	PolicySpecAIAgentHandlingRemediation_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayItemValue) AsFixInSshPathItemValue() (PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayItemValue) AsRebootPathItemValue() (PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Remediation'
func (fpaivs *PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayItemValue) ContainsValue(source *PolicySpec_AIAgentHandling_Remediation) bool {
	switch fpaivs.Selector() {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		return fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayItemValue).ContainsValue(source.GetFixInSsh())
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		return fpaivs.subPathItemValue.(PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayItemValue).ContainsValue(source.GetReboot())
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation: %d", fpaivs.Selector()))
	}
}

// PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues allows storing slice of values for Remediation fields according to their type
type PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecAIAgentHandlingRemediation_FieldPath
}

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

func MustParsePolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayOfValues struct {
	PolicySpecAIAgentHandlingRemediation_FieldTerminalPath
	values interface{}
}

var _ PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues = (*PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorFixInSsh:
		for _, v := range fpaov.values.([]*PolicySpec_AIAgentHandling_Remediation_FixInSSH) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandlingRemediation_FieldPathSelectorReboot:
		for _, v := range fpaov.values.([]*PolicySpec_AIAgentHandling_Remediation_Reboot) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayOfValues) AsFixInSshArrayOfValues() ([]*PolicySpec_AIAgentHandling_Remediation_FixInSSH, bool) {
	res, ok := fpaov.values.([]*PolicySpec_AIAgentHandling_Remediation_FixInSSH)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandlingRemediation_FieldTerminalPathArrayOfValues) AsRebootArrayOfValues() ([]*PolicySpec_AIAgentHandling_Remediation_Reboot, bool) {
	res, ok := fpaov.values.([]*PolicySpec_AIAgentHandling_Remediation_Reboot)
	return res, ok
}

type PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayOfValues struct {
	PolicySpecAIAgentHandlingRemediation_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues = (*PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayOfValues) AsFixInSshPathArrayOfValues() (PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PolicySpecAIAgentHandlingRemediation_FieldSubPathArrayOfValues) AsRebootPathArrayOfValues() (PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelector int32

const (
	PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelectorClientName PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelector = 0
)

func (s PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelector) String() string {
	switch s {
	case PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelectorClientName:
		return "client_name"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH: %d", s))
	}
}

func BuildPolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "client_name", "clientName", "client-name":
			return &PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelectorClientName}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH", fp)
}

func ParsePolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath(rawField string) (PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath(fp)
}

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath(rawField string) PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath {
	fp, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath struct {
	selector PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelector
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath = (*PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath)(nil)

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath) Selector() PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath) ClearValue(item *PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH) {
	if item != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelectorClientName:
			item.ClientName = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH))
}

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

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath) WithIValue(value interface{}) PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelectorClientName:
		return &PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH: %d", fp.selector))
	}
}

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayOfValues {
	fpaov := &PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelectorClientName:
		return &PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue allows storing values for DeviceSSH fields according to their type
type PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue interface {
	PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH)
	CompareWith(*PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH) (cmp int, comparable bool)
}

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue(pathStr, valueStr string) PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue {
	fpv, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathValue = (*PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'DeviceSSH' as interface{}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathValue) AsClientNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object DeviceSSH
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathValue) SetTo(target **PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH) {
	if *target == nil {
		*target = new(PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH)
	}
	switch fpv.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelectorClientName:
		(*target).ClientName = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathArrayItemValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayItemValue = (*PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH) (interface{}, bool) {
	return nil, false
}

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

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

// PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayOfValues allows storing slice of values for DeviceSSH fields according to their type
type PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPath
}

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathArrayOfValues struct {
	PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPath
	values interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathArrayOfValues = (*PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldPathSelectorClientName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityDeviceSSH_FieldTerminalPathArrayOfValues) AsClientNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelector int32

const (
	PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain    PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelector = 0
	PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelector = 1
	PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName       PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelector = 2
	PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName      PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelector = 3
)

func (s PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelector) String() string {
	switch s {
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
		return "service_domain"
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
		return "provider_name_tmpl"
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
		return "client_name"
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
		return "service_name"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH: %d", s))
	}
}

func BuildPolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service_domain", "serviceDomain", "service-domain":
			return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain}, nil
		case "provider_name_tmpl", "providerNameTmpl", "provider-name-tmpl":
			return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl}, nil
		case "client_name", "clientName", "client-name":
			return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName}, nil
		case "service_name", "serviceName", "service-name":
			return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH", fp)
}

func ParsePolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath(rawField string) (PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath(fp)
}

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath(rawField string) PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath {
	fp, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath struct {
	selector PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelector
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath = (*PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath)(nil)

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath) Selector() PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH
func (fp *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath) Get(source *PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
			values = append(values, source.ServiceDomain)
		case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
			values = append(values, source.ProviderNameTmpl)
		case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
			values = append(values, source.ClientName)
		case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
			values = append(values, source.ServiceName)
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH
func (fp *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath) GetSingle(source *PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
		return source.GetServiceDomain(), source != nil
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
		return source.GetProviderNameTmpl(), source != nil
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
		return source.GetClientName(), source != nil
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
		return source.GetServiceName(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
		return ""
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
		return ""
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
		return ""
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH: %d", fp.selector))
	}
}

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath) ClearValue(item *PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) {
	if item != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
			item.ServiceDomain = ""
		case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
			item.ProviderNameTmpl = ""
		case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
			item.ClientName = ""
		case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
			item.ServiceName = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain ||
		fp.selector == PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl ||
		fp.selector == PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName ||
		fp.selector == PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName
}

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath) WithIValue(value interface{}) PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
		return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
		return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
		return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
		return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH: %d", fp.selector))
	}
}

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayOfValues {
	fpaov := &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
		return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
		return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
		return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
		return &PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue allows storing values for ProxiesSSH fields according to their type
type PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue interface {
	PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH)
	CompareWith(*PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) (cmp int, comparable bool)
}

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue(pathStr, valueStr string) PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue {
	fpv, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathValue = (*PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ProxiesSSH' as interface{}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue) AsServiceDomainValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue) AsProviderNameTmplValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue) AsClientNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue) AsServiceNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object ProxiesSSH
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue) SetTo(target **PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) {
	if *target == nil {
		*target = new(PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH)
	}
	switch fpv.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
		(*target).ServiceDomain = fpv.value.(string)
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
		(*target).ProviderNameTmpl = fpv.value.(string)
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
		(*target).ClientName = fpv.value.(string)
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
		(*target).ServiceName = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue' with the value under path in 'PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH'.
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathValue) CompareWith(source *PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) (int, bool) {
	switch fpv.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
		leftValue := fpv.value.(string)
		rightValue := source.GetServiceDomain()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
		leftValue := fpv.value.(string)
		rightValue := source.GetProviderNameTmpl()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
		leftValue := fpv.value.(string)
		rightValue := source.GetClientName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
		leftValue := fpv.value.(string)
		rightValue := source.GetServiceName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH: %d", fpv.selector))
	}
}

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

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

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayItemValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayItemValue = (*PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) (interface{}, bool) {
	return nil, false
}

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

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

// PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayOfValues allows storing slice of values for ProxiesSSH fields according to their type
type PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPath
}

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues struct {
	PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPath
	values interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathArrayOfValues = (*PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceDomain:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorProviderNameTmpl:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorClientName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldPathSelectorServiceName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues) AsServiceDomainArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues) AsProviderNameTmplArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues) AsClientNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityProxiesSSH_FieldTerminalPathArrayOfValues) AsServiceNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelector int32

const (
	PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelector = 0
	PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername   PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelector = 1
)

func (s PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelector) String() string {
	switch s {
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName:
		return "client_name"
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername:
		return "username"
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH: %d", s))
	}
}

func BuildPolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath(fp gotenobject.RawFieldPath) (PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "client_name", "clientName", "client-name":
			return &PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName}, nil
		case "username":
			return &PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath{selector: PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH", fp)
}

func ParsePolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath(rawField string) (PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath(fp)
}

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath(rawField string) PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath {
	fp, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath struct {
	selector PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelector
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath = (*PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath)(nil)

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath) Selector() PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH
func (fp *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath) GetSingle(source *PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) (interface{}, bool) {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName:
		return source.GetClientName(), source != nil
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername:
		return source.GetUsername(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH: %d", fp.selector))
	}
}

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

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath) ClearValue(item *PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) {
	if item != nil {
		switch fp.selector {
		case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName:
			item.ClientName = ""
		case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername:
			item.Username = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH: %d", fp.selector))
		}
	}
}

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH))
}

// IsLeaf - whether field path is holds simple value
func (fp *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName ||
		fp.selector == PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername
}

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath) WithIValue(value interface{}) PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue {
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName:
		return &PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath: *fp, value: value.(string)}
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername:
		return &PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue{PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH: %d", fp.selector))
	}
}

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

func (fp *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayOfValues {
	fpaov := &PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath: *fp}
	switch fp.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName:
		return &PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath: *fp, values: values.([]string)}
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername:
		return &PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue allows storing values for PodSSH fields according to their type
type PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue interface {
	PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH)
	CompareWith(*PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) (cmp int, comparable bool)
}

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue(pathStr, valueStr string) PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue {
	fpv, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathValue = (*PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PodSSH' as interface{}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue) AsClientNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue) AsUsernameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object PodSSH
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue) SetTo(target **PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) {
	if *target == nil {
		*target = new(PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH)
	}
	switch fpv.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName:
		(*target).ClientName = fpv.value.(string)
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername:
		(*target).Username = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue' with the value under path in 'PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH'.
func (fpv *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathValue) CompareWith(source *PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) (int, bool) {
	switch fpv.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName:
		leftValue := fpv.value.(string)
		rightValue := source.GetClientName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername:
		leftValue := fpv.value.(string)
		rightValue := source.GetUsername()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH: %d", fpv.selector))
	}
}

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

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

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayItemValue struct {
	PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayItemValue = (*PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) (interface{}, bool) {
	return nil, false
}

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

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

// PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayOfValues allows storing slice of values for PodSSH fields according to their type
type PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPath
}

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

func MustParsePolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayOfValues struct {
	PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPath
	values interface{}
}

var _ PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathArrayOfValues = (*PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorClientName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldPathSelectorUsername:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayOfValues) AsClientNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PolicySpecAIAgentHandlingEdgeConnectivityPodSSH_FieldTerminalPathArrayOfValues) AsUsernameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathSelector int32

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

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

func ParsePolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath(rawField string) (PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath(fp)
}

func MustParsePolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath(rawField string) PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath {
	fp, err := ParsePolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPath struct {
	selector PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathSelector
}

var _ PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath = (*PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPath)(nil)

func (fp *PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPath) Selector() PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_AIAgentHandling_Remediation_FixInSSH))
}

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

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

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

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

func (fp *PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayOfValues {
	fpaov := &PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPath: *fp}
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation_FixInSSH: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue allows storing values for FixInSSH fields according to their type
type PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue interface {
	PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_AIAgentHandling_Remediation_FixInSSH)
	CompareWith(*PolicySpec_AIAgentHandling_Remediation_FixInSSH) (cmp int, comparable bool)
}

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

func MustParsePolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue(pathStr, valueStr string) PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue {
	fpv, err := ParsePolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPathValue struct {
	PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathValue = (*PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPathValue)(nil)

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

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

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

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

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

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

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

func MustParsePolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPathArrayItemValue struct {
	PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayItemValue = (*PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_AIAgentHandling_Remediation_FixInSSH) (interface{}, bool) {
	return nil, false
}

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

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

// PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayOfValues allows storing slice of values for FixInSSH fields according to their type
type PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPath
}

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

func MustParsePolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPathArrayOfValues struct {
	PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPath
	values interface{}
}

var _ PolicySpecAIAgentHandlingRemediationFixInSSH_FieldPathArrayOfValues = (*PolicySpecAIAgentHandlingRemediationFixInSSH_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type PolicySpecAIAgentHandlingRemediationReboot_FieldPathSelector int32

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

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

func ParsePolicySpecAIAgentHandlingRemediationReboot_FieldPath(rawField string) (PolicySpecAIAgentHandlingRemediationReboot_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPolicySpecAIAgentHandlingRemediationReboot_FieldPath(fp)
}

func MustParsePolicySpecAIAgentHandlingRemediationReboot_FieldPath(rawField string) PolicySpecAIAgentHandlingRemediationReboot_FieldPath {
	fp, err := ParsePolicySpecAIAgentHandlingRemediationReboot_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPath struct {
	selector PolicySpecAIAgentHandlingRemediationReboot_FieldPathSelector
}

var _ PolicySpecAIAgentHandlingRemediationReboot_FieldPath = (*PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPath)(nil)

func (fp *PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPath) Selector() PolicySpecAIAgentHandlingRemediationReboot_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PolicySpec_AIAgentHandling_Remediation_Reboot))
}

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

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

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

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

func (fp *PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPath) WithIArrayOfValues(values interface{}) PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayOfValues {
	fpaov := &PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPathArrayOfValues{PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPath: *fp}
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for PolicySpec_AIAgentHandling_Remediation_Reboot: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PolicySpecAIAgentHandlingRemediationReboot_FieldPathValue allows storing values for Reboot fields according to their type
type PolicySpecAIAgentHandlingRemediationReboot_FieldPathValue interface {
	PolicySpecAIAgentHandlingRemediationReboot_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PolicySpec_AIAgentHandling_Remediation_Reboot)
	CompareWith(*PolicySpec_AIAgentHandling_Remediation_Reboot) (cmp int, comparable bool)
}

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

func MustParsePolicySpecAIAgentHandlingRemediationReboot_FieldPathValue(pathStr, valueStr string) PolicySpecAIAgentHandlingRemediationReboot_FieldPathValue {
	fpv, err := ParsePolicySpecAIAgentHandlingRemediationReboot_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPathValue struct {
	PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingRemediationReboot_FieldPathValue = (*PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPathValue)(nil)

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

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

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

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

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

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

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

func MustParsePolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayItemValue(pathStr, valueStr string) PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayItemValue {
	fpaiv, err := ParsePolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPathArrayItemValue struct {
	PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPath
	value interface{}
}

var _ PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayItemValue = (*PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPathArrayItemValue) GetSingle(source *PolicySpec_AIAgentHandling_Remediation_Reboot) (interface{}, bool) {
	return nil, false
}

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

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

// PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayOfValues allows storing slice of values for Reboot fields according to their type
type PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PolicySpecAIAgentHandlingRemediationReboot_FieldPath
}

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

func MustParsePolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayOfValues(pathStr, valuesStr string) PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayOfValues {
	fpaov, err := ParsePolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPathArrayOfValues struct {
	PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPath
	values interface{}
}

var _ PolicySpecAIAgentHandlingRemediationReboot_FieldPathArrayOfValues = (*PolicySpecAIAgentHandlingRemediationReboot_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type NotificationChannelSpec_FieldPathSelector int32

const (
	NotificationChannelSpec_FieldPathSelectorEnabled                             NotificationChannelSpec_FieldPathSelector = 0
	NotificationChannelSpec_FieldPathSelectorType                                NotificationChannelSpec_FieldPathSelector = 1
	NotificationChannelSpec_FieldPathSelectorEnabledKinds                        NotificationChannelSpec_FieldPathSelector = 2
	NotificationChannelSpec_FieldPathSelectorEmail                               NotificationChannelSpec_FieldPathSelector = 3
	NotificationChannelSpec_FieldPathSelectorSlack                               NotificationChannelSpec_FieldPathSelector = 4
	NotificationChannelSpec_FieldPathSelectorWebhook                             NotificationChannelSpec_FieldPathSelector = 5
	NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode            NotificationChannelSpec_FieldPathSelector = 6
	NotificationChannelSpec_FieldPathSelectorNotificationMask                    NotificationChannelSpec_FieldPathSelector = 7
	NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg                 NotificationChannelSpec_FieldPathSelector = 8
	NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing NotificationChannelSpec_FieldPathSelector = 9
)

func (s NotificationChannelSpec_FieldPathSelector) String() string {
	switch s {
	case NotificationChannelSpec_FieldPathSelectorEnabled:
		return "enabled"
	case NotificationChannelSpec_FieldPathSelectorType:
		return "type"
	case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
		return "enabled_kinds"
	case NotificationChannelSpec_FieldPathSelectorEmail:
		return "email"
	case NotificationChannelSpec_FieldPathSelectorSlack:
		return "slack"
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		return "webhook"
	case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
		return "notification_language_code"
	case NotificationChannelSpec_FieldPathSelectorNotificationMask:
		return "notification_mask"
	case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
		return "max_alert_bodies_in_msg"
	case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
		return "put_only_alerts_counter_when_overflowing"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", s))
	}
}

func BuildNotificationChannelSpec_FieldPath(fp gotenobject.RawFieldPath) (NotificationChannelSpec_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationChannelSpec")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "enabled":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorEnabled}, nil
		case "type":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorType}, nil
		case "enabled_kinds", "enabledKinds", "enabled-kinds":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorEnabledKinds}, nil
		case "email":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorEmail}, nil
		case "slack":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorSlack}, nil
		case "webhook":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorWebhook}, nil
		case "notification_language_code", "notificationLanguageCode", "notification-language-code":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode}, nil
		case "notification_mask", "notificationMask", "notification-mask":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorNotificationMask}, nil
		case "max_alert_bodies_in_msg", "maxAlertBodiesInMsg", "max-alert-bodies-in-msg":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg}, nil
		case "put_only_alerts_counter_when_overflowing", "putOnlyAlertsCounterWhenOverflowing", "put-only-alerts-counter-when-overflowing":
			return &NotificationChannelSpec_FieldTerminalPath{selector: NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing}, nil
		}
	} else {
		switch fp[0] {
		case "email":
			if subpath, err := BuildNotificationChannelSpecEmail_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationChannelSpec_FieldSubPath{selector: NotificationChannelSpec_FieldPathSelectorEmail, subPath: subpath}, nil
			}
		case "slack":
			if subpath, err := BuildNotificationChannelSpecSlack_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationChannelSpec_FieldSubPath{selector: NotificationChannelSpec_FieldPathSelectorSlack, subPath: subpath}, nil
			}
		case "webhook":
			if subpath, err := BuildNotificationChannelSpecWebhook_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationChannelSpec_FieldSubPath{selector: NotificationChannelSpec_FieldPathSelectorWebhook, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationChannelSpec", fp)
}

func ParseNotificationChannelSpec_FieldPath(rawField string) (NotificationChannelSpec_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationChannelSpec_FieldPath(fp)
}

func MustParseNotificationChannelSpec_FieldPath(rawField string) NotificationChannelSpec_FieldPath {
	fp, err := ParseNotificationChannelSpec_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationChannelSpec_FieldTerminalPath struct {
	selector NotificationChannelSpec_FieldPathSelector
}

var _ NotificationChannelSpec_FieldPath = (*NotificationChannelSpec_FieldTerminalPath)(nil)

func (fp *NotificationChannelSpec_FieldTerminalPath) Selector() NotificationChannelSpec_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationChannelSpec
func (fp *NotificationChannelSpec_FieldTerminalPath) Get(source *NotificationChannelSpec) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationChannelSpec_FieldPathSelectorEnabled:
			values = append(values, source.Enabled)
		case NotificationChannelSpec_FieldPathSelectorType:
			values = append(values, source.Type)
		case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
			for _, value := range source.GetEnabledKinds() {
				values = append(values, value)
			}
		case NotificationChannelSpec_FieldPathSelectorEmail:
			if source.Email != nil {
				values = append(values, source.Email)
			}
		case NotificationChannelSpec_FieldPathSelectorSlack:
			if source.Slack != nil {
				values = append(values, source.Slack)
			}
		case NotificationChannelSpec_FieldPathSelectorWebhook:
			if source.Webhook != nil {
				values = append(values, source.Webhook)
			}
		case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
			values = append(values, source.NotificationLanguageCode)
		case NotificationChannelSpec_FieldPathSelectorNotificationMask:
			if source.NotificationMask != nil {
				values = append(values, source.NotificationMask)
			}
		case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
			values = append(values, source.MaxAlertBodiesInMsg)
		case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
			values = append(values, source.PutOnlyAlertsCounterWhenOverflowing)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationChannelSpec
func (fp *NotificationChannelSpec_FieldTerminalPath) GetSingle(source *NotificationChannelSpec) (interface{}, bool) {
	switch fp.selector {
	case NotificationChannelSpec_FieldPathSelectorEnabled:
		return source.GetEnabled(), source != nil
	case NotificationChannelSpec_FieldPathSelectorType:
		return source.GetType(), source != nil
	case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
		res := source.GetEnabledKinds()
		return res, res != nil
	case NotificationChannelSpec_FieldPathSelectorEmail:
		res := source.GetEmail()
		return res, res != nil
	case NotificationChannelSpec_FieldPathSelectorSlack:
		res := source.GetSlack()
		return res, res != nil
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		res := source.GetWebhook()
		return res, res != nil
	case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
		return source.GetNotificationLanguageCode(), source != nil
	case NotificationChannelSpec_FieldPathSelectorNotificationMask:
		res := source.GetNotificationMask()
		return res, res != nil
	case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
		return source.GetMaxAlertBodiesInMsg(), source != nil
	case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
		return source.GetPutOnlyAlertsCounterWhenOverflowing(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationChannelSpec_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationChannelSpec_FieldPathSelectorEnabled:
		return false
	case NotificationChannelSpec_FieldPathSelectorType:
		return NotificationChannelSpec_TYPE_UNSPECIFIED
	case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
		return ([]NotificationChannelSpec_EventKind)(nil)
	case NotificationChannelSpec_FieldPathSelectorEmail:
		return (*NotificationChannelSpec_Email)(nil)
	case NotificationChannelSpec_FieldPathSelectorSlack:
		return (*NotificationChannelSpec_Slack)(nil)
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		return (*NotificationChannelSpec_Webhook)(nil)
	case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
		return ""
	case NotificationChannelSpec_FieldPathSelectorNotificationMask:
		return (*fieldmaskpb.FieldMask)(nil)
	case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
		return int32(0)
	case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpec_FieldTerminalPath) ClearValue(item *NotificationChannelSpec) {
	if item != nil {
		switch fp.selector {
		case NotificationChannelSpec_FieldPathSelectorEnabled:
			item.Enabled = false
		case NotificationChannelSpec_FieldPathSelectorType:
			item.Type = NotificationChannelSpec_TYPE_UNSPECIFIED
		case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
			item.EnabledKinds = nil
		case NotificationChannelSpec_FieldPathSelectorEmail:
			item.Email = nil
		case NotificationChannelSpec_FieldPathSelectorSlack:
			item.Slack = nil
		case NotificationChannelSpec_FieldPathSelectorWebhook:
			item.Webhook = nil
		case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
			item.NotificationLanguageCode = ""
		case NotificationChannelSpec_FieldPathSelectorNotificationMask:
			item.NotificationMask = nil
		case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
			item.MaxAlertBodiesInMsg = int32(0)
		case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
			item.PutOnlyAlertsCounterWhenOverflowing = false
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fp.selector))
		}
	}
}

func (fp *NotificationChannelSpec_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationChannelSpec))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationChannelSpec_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationChannelSpec_FieldPathSelectorEnabled ||
		fp.selector == NotificationChannelSpec_FieldPathSelectorType ||
		fp.selector == NotificationChannelSpec_FieldPathSelectorEnabledKinds ||
		fp.selector == NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode ||
		fp.selector == NotificationChannelSpec_FieldPathSelectorNotificationMask ||
		fp.selector == NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg ||
		fp.selector == NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing
}

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

func (fp *NotificationChannelSpec_FieldTerminalPath) WithIValue(value interface{}) NotificationChannelSpec_FieldPathValue {
	switch fp.selector {
	case NotificationChannelSpec_FieldPathSelectorEnabled:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(bool)}
	case NotificationChannelSpec_FieldPathSelectorType:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(NotificationChannelSpec_Type)}
	case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.([]NotificationChannelSpec_EventKind)}
	case NotificationChannelSpec_FieldPathSelectorEmail:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(*NotificationChannelSpec_Email)}
	case NotificationChannelSpec_FieldPathSelectorSlack:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(*NotificationChannelSpec_Slack)}
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(*NotificationChannelSpec_Webhook)}
	case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationChannelSpec_FieldPathSelectorNotificationMask:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(*fieldmaskpb.FieldMask)}
	case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(int32)}
	case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
		return &NotificationChannelSpec_FieldTerminalPathValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fp.selector))
	}
}

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

func (fp *NotificationChannelSpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationChannelSpec_FieldPathArrayOfValues {
	fpaov := &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationChannelSpec_FieldPathSelectorEnabled:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([]bool)}
	case NotificationChannelSpec_FieldPathSelectorType:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([]NotificationChannelSpec_Type)}
	case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([][]NotificationChannelSpec_EventKind)}
	case NotificationChannelSpec_FieldPathSelectorEmail:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([]*NotificationChannelSpec_Email)}
	case NotificationChannelSpec_FieldPathSelectorSlack:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([]*NotificationChannelSpec_Slack)}
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([]*NotificationChannelSpec_Webhook)}
	case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationChannelSpec_FieldPathSelectorNotificationMask:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([]*fieldmaskpb.FieldMask)}
	case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([]int32)}
	case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
		return &NotificationChannelSpec_FieldTerminalPathArrayOfValues{NotificationChannelSpec_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *NotificationChannelSpec_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationChannelSpec_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
		return &NotificationChannelSpec_FieldTerminalPathArrayItemValue{NotificationChannelSpec_FieldTerminalPath: *fp, value: value.(NotificationChannelSpec_EventKind)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fp.selector))
	}
}

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

type NotificationChannelSpec_FieldSubPath struct {
	selector NotificationChannelSpec_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationChannelSpec_FieldPath = (*NotificationChannelSpec_FieldSubPath)(nil)

func (fps *NotificationChannelSpec_FieldSubPath) Selector() NotificationChannelSpec_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationChannelSpec_FieldSubPath) AsEmailSubPath() (NotificationChannelSpecEmail_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationChannelSpecEmail_FieldPath)
	return res, ok
}
func (fps *NotificationChannelSpec_FieldSubPath) AsSlackSubPath() (NotificationChannelSpecSlack_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationChannelSpecSlack_FieldPath)
	return res, ok
}
func (fps *NotificationChannelSpec_FieldSubPath) AsWebhookSubPath() (NotificationChannelSpecWebhook_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationChannelSpecWebhook_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source NotificationChannelSpec
func (fps *NotificationChannelSpec_FieldSubPath) Get(source *NotificationChannelSpec) (values []interface{}) {
	switch fps.selector {
	case NotificationChannelSpec_FieldPathSelectorEmail:
		values = append(values, fps.subPath.GetRaw(source.GetEmail())...)
	case NotificationChannelSpec_FieldPathSelectorSlack:
		values = append(values, fps.subPath.GetRaw(source.GetSlack())...)
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		values = append(values, fps.subPath.GetRaw(source.GetWebhook())...)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source NotificationChannelSpec
func (fps *NotificationChannelSpec_FieldSubPath) GetSingle(source *NotificationChannelSpec) (interface{}, bool) {
	switch fps.selector {
	case NotificationChannelSpec_FieldPathSelectorEmail:
		if source.GetEmail() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetEmail())
	case NotificationChannelSpec_FieldPathSelectorSlack:
		if source.GetSlack() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetSlack())
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		if source.GetWebhook() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetWebhook())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fps.selector))
	}
}

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

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

func (fps *NotificationChannelSpec_FieldSubPath) ClearValue(item *NotificationChannelSpec) {
	if item != nil {
		switch fps.selector {
		case NotificationChannelSpec_FieldPathSelectorEmail:
			fps.subPath.ClearValueRaw(item.Email)
		case NotificationChannelSpec_FieldPathSelectorSlack:
			fps.subPath.ClearValueRaw(item.Slack)
		case NotificationChannelSpec_FieldPathSelectorWebhook:
			fps.subPath.ClearValueRaw(item.Webhook)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fps.selector))
		}
	}
}

func (fps *NotificationChannelSpec_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationChannelSpec))
}

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

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

func (fps *NotificationChannelSpec_FieldSubPath) WithIValue(value interface{}) NotificationChannelSpec_FieldPathValue {
	return &NotificationChannelSpec_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationChannelSpec_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationChannelSpec_FieldPathArrayOfValues {
	return &NotificationChannelSpec_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationChannelSpec_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationChannelSpec_FieldPathArrayItemValue {
	return &NotificationChannelSpec_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseNotificationChannelSpec_FieldPathValue(pathStr, valueStr string) NotificationChannelSpec_FieldPathValue {
	fpv, err := ParseNotificationChannelSpec_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationChannelSpec_FieldTerminalPathValue struct {
	NotificationChannelSpec_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpec_FieldPathValue = (*NotificationChannelSpec_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'NotificationChannelSpec' as interface{}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsEnabledValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsTypeValue() (NotificationChannelSpec_Type, bool) {
	res, ok := fpv.value.(NotificationChannelSpec_Type)
	return res, ok
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsEnabledKindsValue() ([]NotificationChannelSpec_EventKind, bool) {
	res, ok := fpv.value.([]NotificationChannelSpec_EventKind)
	return res, ok
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsEmailValue() (*NotificationChannelSpec_Email, bool) {
	res, ok := fpv.value.(*NotificationChannelSpec_Email)
	return res, ok
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsSlackValue() (*NotificationChannelSpec_Slack, bool) {
	res, ok := fpv.value.(*NotificationChannelSpec_Slack)
	return res, ok
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsWebhookValue() (*NotificationChannelSpec_Webhook, bool) {
	res, ok := fpv.value.(*NotificationChannelSpec_Webhook)
	return res, ok
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsNotificationLanguageCodeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsNotificationMaskValue() (*fieldmaskpb.FieldMask, bool) {
	res, ok := fpv.value.(*fieldmaskpb.FieldMask)
	return res, ok
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsMaxAlertBodiesInMsgValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) AsPutOnlyAlertsCounterWhenOverflowingValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object NotificationChannelSpec
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) SetTo(target **NotificationChannelSpec) {
	if *target == nil {
		*target = new(NotificationChannelSpec)
	}
	switch fpv.selector {
	case NotificationChannelSpec_FieldPathSelectorEnabled:
		(*target).Enabled = fpv.value.(bool)
	case NotificationChannelSpec_FieldPathSelectorType:
		(*target).Type = fpv.value.(NotificationChannelSpec_Type)
	case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
		(*target).EnabledKinds = fpv.value.([]NotificationChannelSpec_EventKind)
	case NotificationChannelSpec_FieldPathSelectorEmail:
		(*target).Email = fpv.value.(*NotificationChannelSpec_Email)
	case NotificationChannelSpec_FieldPathSelectorSlack:
		(*target).Slack = fpv.value.(*NotificationChannelSpec_Slack)
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		(*target).Webhook = fpv.value.(*NotificationChannelSpec_Webhook)
	case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
		(*target).NotificationLanguageCode = fpv.value.(string)
	case NotificationChannelSpec_FieldPathSelectorNotificationMask:
		(*target).NotificationMask = fpv.value.(*fieldmaskpb.FieldMask)
	case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
		(*target).MaxAlertBodiesInMsg = fpv.value.(int32)
	case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
		(*target).PutOnlyAlertsCounterWhenOverflowing = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationChannelSpec_FieldTerminalPathValue' with the value under path in 'NotificationChannelSpec'.
func (fpv *NotificationChannelSpec_FieldTerminalPathValue) CompareWith(source *NotificationChannelSpec) (int, bool) {
	switch fpv.selector {
	case NotificationChannelSpec_FieldPathSelectorEnabled:
		leftValue := fpv.value.(bool)
		rightValue := source.GetEnabled()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationChannelSpec_FieldPathSelectorType:
		leftValue := fpv.value.(NotificationChannelSpec_Type)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
		return 0, false
	case NotificationChannelSpec_FieldPathSelectorEmail:
		return 0, false
	case NotificationChannelSpec_FieldPathSelectorSlack:
		return 0, false
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		return 0, false
	case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
		leftValue := fpv.value.(string)
		rightValue := source.GetNotificationLanguageCode()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationChannelSpec_FieldPathSelectorNotificationMask:
		return 0, false
	case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
		leftValue := fpv.value.(int32)
		rightValue := source.GetMaxAlertBodiesInMsg()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
		leftValue := fpv.value.(bool)
		rightValue := source.GetPutOnlyAlertsCounterWhenOverflowing()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fpv.selector))
	}
}

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

type NotificationChannelSpec_FieldSubPathValue struct {
	NotificationChannelSpec_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationChannelSpec_FieldPathValue = (*NotificationChannelSpec_FieldSubPathValue)(nil)

func (fpvs *NotificationChannelSpec_FieldSubPathValue) AsEmailPathValue() (NotificationChannelSpecEmail_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationChannelSpecEmail_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationChannelSpec_FieldSubPathValue) AsSlackPathValue() (NotificationChannelSpecSlack_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationChannelSpecSlack_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationChannelSpec_FieldSubPathValue) AsWebhookPathValue() (NotificationChannelSpecWebhook_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationChannelSpecWebhook_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationChannelSpec_FieldSubPathValue) SetTo(target **NotificationChannelSpec) {
	if *target == nil {
		*target = new(NotificationChannelSpec)
	}
	switch fpvs.Selector() {
	case NotificationChannelSpec_FieldPathSelectorEmail:
		fpvs.subPathValue.(NotificationChannelSpecEmail_FieldPathValue).SetTo(&(*target).Email)
	case NotificationChannelSpec_FieldPathSelectorSlack:
		fpvs.subPathValue.(NotificationChannelSpecSlack_FieldPathValue).SetTo(&(*target).Slack)
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		fpvs.subPathValue.(NotificationChannelSpecWebhook_FieldPathValue).SetTo(&(*target).Webhook)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationChannelSpec_FieldSubPathValue) CompareWith(source *NotificationChannelSpec) (int, bool) {
	switch fpvs.Selector() {
	case NotificationChannelSpec_FieldPathSelectorEmail:
		return fpvs.subPathValue.(NotificationChannelSpecEmail_FieldPathValue).CompareWith(source.GetEmail())
	case NotificationChannelSpec_FieldPathSelectorSlack:
		return fpvs.subPathValue.(NotificationChannelSpecSlack_FieldPathValue).CompareWith(source.GetSlack())
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		return fpvs.subPathValue.(NotificationChannelSpecWebhook_FieldPathValue).CompareWith(source.GetWebhook())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationChannelSpec_FieldPathArrayItemValue(pathStr, valueStr string) NotificationChannelSpec_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationChannelSpec_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationChannelSpec_FieldTerminalPathArrayItemValue struct {
	NotificationChannelSpec_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpec_FieldPathArrayItemValue = (*NotificationChannelSpec_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationChannelSpec as interface{}
func (fpaiv *NotificationChannelSpec_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *NotificationChannelSpec_FieldTerminalPathArrayItemValue) AsEnabledKindsItemValue() (NotificationChannelSpec_EventKind, bool) {
	res, ok := fpaiv.value.(NotificationChannelSpec_EventKind)
	return res, ok
}

func (fpaiv *NotificationChannelSpec_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationChannelSpec) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *NotificationChannelSpec_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationChannelSpec_FieldSubPathArrayItemValue) AsEmailPathItemValue() (NotificationChannelSpecEmail_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationChannelSpecEmail_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationChannelSpec_FieldSubPathArrayItemValue) AsSlackPathItemValue() (NotificationChannelSpecSlack_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationChannelSpecSlack_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationChannelSpec_FieldSubPathArrayItemValue) AsWebhookPathItemValue() (NotificationChannelSpecWebhook_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationChannelSpecWebhook_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'NotificationChannelSpec'
func (fpaivs *NotificationChannelSpec_FieldSubPathArrayItemValue) ContainsValue(source *NotificationChannelSpec) bool {
	switch fpaivs.Selector() {
	case NotificationChannelSpec_FieldPathSelectorEmail:
		return fpaivs.subPathItemValue.(NotificationChannelSpecEmail_FieldPathArrayItemValue).ContainsValue(source.GetEmail())
	case NotificationChannelSpec_FieldPathSelectorSlack:
		return fpaivs.subPathItemValue.(NotificationChannelSpecSlack_FieldPathArrayItemValue).ContainsValue(source.GetSlack())
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		return fpaivs.subPathItemValue.(NotificationChannelSpecWebhook_FieldPathArrayItemValue).ContainsValue(source.GetWebhook())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec: %d", fpaivs.Selector()))
	}
}

// NotificationChannelSpec_FieldPathArrayOfValues allows storing slice of values for NotificationChannelSpec fields according to their type
type NotificationChannelSpec_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationChannelSpec_FieldPath
}

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

func MustParseNotificationChannelSpec_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationChannelSpec_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationChannelSpec_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationChannelSpec_FieldTerminalPathArrayOfValues struct {
	NotificationChannelSpec_FieldTerminalPath
	values interface{}
}

var _ NotificationChannelSpec_FieldPathArrayOfValues = (*NotificationChannelSpec_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationChannelSpec_FieldPathSelectorEnabled:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case NotificationChannelSpec_FieldPathSelectorType:
		for _, v := range fpaov.values.([]NotificationChannelSpec_Type) {
			values = append(values, v)
		}
	case NotificationChannelSpec_FieldPathSelectorEnabledKinds:
		for _, v := range fpaov.values.([][]NotificationChannelSpec_EventKind) {
			values = append(values, v)
		}
	case NotificationChannelSpec_FieldPathSelectorEmail:
		for _, v := range fpaov.values.([]*NotificationChannelSpec_Email) {
			values = append(values, v)
		}
	case NotificationChannelSpec_FieldPathSelectorSlack:
		for _, v := range fpaov.values.([]*NotificationChannelSpec_Slack) {
			values = append(values, v)
		}
	case NotificationChannelSpec_FieldPathSelectorWebhook:
		for _, v := range fpaov.values.([]*NotificationChannelSpec_Webhook) {
			values = append(values, v)
		}
	case NotificationChannelSpec_FieldPathSelectorNotificationLanguageCode:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationChannelSpec_FieldPathSelectorNotificationMask:
		for _, v := range fpaov.values.([]*fieldmaskpb.FieldMask) {
			values = append(values, v)
		}
	case NotificationChannelSpec_FieldPathSelectorMaxAlertBodiesInMsg:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case NotificationChannelSpec_FieldPathSelectorPutOnlyAlertsCounterWhenOverflowing:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsEnabledArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]NotificationChannelSpec_Type, bool) {
	res, ok := fpaov.values.([]NotificationChannelSpec_Type)
	return res, ok
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsEnabledKindsArrayOfValues() ([][]NotificationChannelSpec_EventKind, bool) {
	res, ok := fpaov.values.([][]NotificationChannelSpec_EventKind)
	return res, ok
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsEmailArrayOfValues() ([]*NotificationChannelSpec_Email, bool) {
	res, ok := fpaov.values.([]*NotificationChannelSpec_Email)
	return res, ok
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsSlackArrayOfValues() ([]*NotificationChannelSpec_Slack, bool) {
	res, ok := fpaov.values.([]*NotificationChannelSpec_Slack)
	return res, ok
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsWebhookArrayOfValues() ([]*NotificationChannelSpec_Webhook, bool) {
	res, ok := fpaov.values.([]*NotificationChannelSpec_Webhook)
	return res, ok
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsNotificationLanguageCodeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsNotificationMaskArrayOfValues() ([]*fieldmaskpb.FieldMask, bool) {
	res, ok := fpaov.values.([]*fieldmaskpb.FieldMask)
	return res, ok
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsMaxAlertBodiesInMsgArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *NotificationChannelSpec_FieldTerminalPathArrayOfValues) AsPutOnlyAlertsCounterWhenOverflowingArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type NotificationChannelSpec_FieldSubPathArrayOfValues struct {
	NotificationChannelSpec_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationChannelSpec_FieldPathArrayOfValues = (*NotificationChannelSpec_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationChannelSpec_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationChannelSpec_FieldSubPathArrayOfValues) AsEmailPathArrayOfValues() (NotificationChannelSpecEmail_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationChannelSpecEmail_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationChannelSpec_FieldSubPathArrayOfValues) AsSlackPathArrayOfValues() (NotificationChannelSpecSlack_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationChannelSpecSlack_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationChannelSpec_FieldSubPathArrayOfValues) AsWebhookPathArrayOfValues() (NotificationChannelSpecWebhook_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationChannelSpecWebhook_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationChannelSpecEmail_FieldPathSelector int32

const (
	NotificationChannelSpecEmail_FieldPathSelectorAddresses NotificationChannelSpecEmail_FieldPathSelector = 0
)

func (s NotificationChannelSpecEmail_FieldPathSelector) String() string {
	switch s {
	case NotificationChannelSpecEmail_FieldPathSelectorAddresses:
		return "addresses"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Email: %d", s))
	}
}

func BuildNotificationChannelSpecEmail_FieldPath(fp gotenobject.RawFieldPath) (NotificationChannelSpecEmail_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationChannelSpec_Email")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "addresses":
			return &NotificationChannelSpecEmail_FieldTerminalPath{selector: NotificationChannelSpecEmail_FieldPathSelectorAddresses}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationChannelSpec_Email", fp)
}

func ParseNotificationChannelSpecEmail_FieldPath(rawField string) (NotificationChannelSpecEmail_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationChannelSpecEmail_FieldPath(fp)
}

func MustParseNotificationChannelSpecEmail_FieldPath(rawField string) NotificationChannelSpecEmail_FieldPath {
	fp, err := ParseNotificationChannelSpecEmail_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationChannelSpecEmail_FieldTerminalPath struct {
	selector NotificationChannelSpecEmail_FieldPathSelector
}

var _ NotificationChannelSpecEmail_FieldPath = (*NotificationChannelSpecEmail_FieldTerminalPath)(nil)

func (fp *NotificationChannelSpecEmail_FieldTerminalPath) Selector() NotificationChannelSpecEmail_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *NotificationChannelSpecEmail_FieldTerminalPath) ClearValue(item *NotificationChannelSpec_Email) {
	if item != nil {
		switch fp.selector {
		case NotificationChannelSpecEmail_FieldPathSelectorAddresses:
			item.Addresses = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Email: %d", fp.selector))
		}
	}
}

func (fp *NotificationChannelSpecEmail_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationChannelSpec_Email))
}

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

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

func (fp *NotificationChannelSpecEmail_FieldTerminalPath) WithIValue(value interface{}) NotificationChannelSpecEmail_FieldPathValue {
	switch fp.selector {
	case NotificationChannelSpecEmail_FieldPathSelectorAddresses:
		return &NotificationChannelSpecEmail_FieldTerminalPathValue{NotificationChannelSpecEmail_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Email: %d", fp.selector))
	}
}

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

func (fp *NotificationChannelSpecEmail_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationChannelSpecEmail_FieldPathArrayOfValues {
	fpaov := &NotificationChannelSpecEmail_FieldTerminalPathArrayOfValues{NotificationChannelSpecEmail_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationChannelSpecEmail_FieldPathSelectorAddresses:
		return &NotificationChannelSpecEmail_FieldTerminalPathArrayOfValues{NotificationChannelSpecEmail_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Email: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *NotificationChannelSpecEmail_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationChannelSpecEmail_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationChannelSpecEmail_FieldPathSelectorAddresses:
		return &NotificationChannelSpecEmail_FieldTerminalPathArrayItemValue{NotificationChannelSpecEmail_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Email: %d", fp.selector))
	}
}

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

// NotificationChannelSpecEmail_FieldPathValue allows storing values for Email fields according to their type
type NotificationChannelSpecEmail_FieldPathValue interface {
	NotificationChannelSpecEmail_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationChannelSpec_Email)
	CompareWith(*NotificationChannelSpec_Email) (cmp int, comparable bool)
}

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

func MustParseNotificationChannelSpecEmail_FieldPathValue(pathStr, valueStr string) NotificationChannelSpecEmail_FieldPathValue {
	fpv, err := ParseNotificationChannelSpecEmail_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationChannelSpecEmail_FieldTerminalPathValue struct {
	NotificationChannelSpecEmail_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecEmail_FieldPathValue = (*NotificationChannelSpecEmail_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Email' as interface{}
func (fpv *NotificationChannelSpecEmail_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationChannelSpecEmail_FieldTerminalPathValue) AsAddressesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object Email
func (fpv *NotificationChannelSpecEmail_FieldTerminalPathValue) SetTo(target **NotificationChannelSpec_Email) {
	if *target == nil {
		*target = new(NotificationChannelSpec_Email)
	}
	switch fpv.selector {
	case NotificationChannelSpecEmail_FieldPathSelectorAddresses:
		(*target).Addresses = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Email: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecEmail_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*NotificationChannelSpec_Email)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'NotificationChannelSpecEmail_FieldTerminalPathValue' with the value under path in 'NotificationChannelSpec_Email'.
func (fpv *NotificationChannelSpecEmail_FieldTerminalPathValue) CompareWith(source *NotificationChannelSpec_Email) (int, bool) {
	switch fpv.selector {
	case NotificationChannelSpecEmail_FieldPathSelectorAddresses:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Email: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecEmail_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*NotificationChannelSpec_Email))
}

// NotificationChannelSpecEmail_FieldPathArrayItemValue allows storing single item in Path-specific values for Email according to their type
// Present only for array (repeated) types.
type NotificationChannelSpecEmail_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	NotificationChannelSpecEmail_FieldPath
	ContainsValue(*NotificationChannelSpec_Email) bool
}

// ParseNotificationChannelSpecEmail_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseNotificationChannelSpecEmail_FieldPathArrayItemValue(pathStr, valueStr string) (NotificationChannelSpecEmail_FieldPathArrayItemValue, error) {
	fp, err := ParseNotificationChannelSpecEmail_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 Email field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(NotificationChannelSpecEmail_FieldPathArrayItemValue), nil
}

func MustParseNotificationChannelSpecEmail_FieldPathArrayItemValue(pathStr, valueStr string) NotificationChannelSpecEmail_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationChannelSpecEmail_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationChannelSpecEmail_FieldTerminalPathArrayItemValue struct {
	NotificationChannelSpecEmail_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecEmail_FieldPathArrayItemValue = (*NotificationChannelSpecEmail_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationChannelSpec_Email as interface{}
func (fpaiv *NotificationChannelSpecEmail_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *NotificationChannelSpecEmail_FieldTerminalPathArrayItemValue) AsAddressesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *NotificationChannelSpecEmail_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationChannelSpec_Email) (interface{}, bool) {
	return nil, false
}

func (fpaiv *NotificationChannelSpecEmail_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*NotificationChannelSpec_Email))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Email'
func (fpaiv *NotificationChannelSpecEmail_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationChannelSpec_Email) bool {
	slice := fpaiv.NotificationChannelSpecEmail_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
}

// NotificationChannelSpecEmail_FieldPathArrayOfValues allows storing slice of values for Email fields according to their type
type NotificationChannelSpecEmail_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationChannelSpecEmail_FieldPath
}

func ParseNotificationChannelSpecEmail_FieldPathArrayOfValues(pathStr, valuesStr string) (NotificationChannelSpecEmail_FieldPathArrayOfValues, error) {
	fp, err := ParseNotificationChannelSpecEmail_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 Email field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(NotificationChannelSpecEmail_FieldPathArrayOfValues), nil
}

func MustParseNotificationChannelSpecEmail_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationChannelSpecEmail_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationChannelSpecEmail_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationChannelSpecEmail_FieldTerminalPathArrayOfValues struct {
	NotificationChannelSpecEmail_FieldTerminalPath
	values interface{}
}

var _ NotificationChannelSpecEmail_FieldPathArrayOfValues = (*NotificationChannelSpecEmail_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationChannelSpecEmail_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationChannelSpecEmail_FieldPathSelectorAddresses:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationChannelSpecEmail_FieldTerminalPathArrayOfValues) AsAddressesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type NotificationChannelSpecSlack_FieldPath interface {
	gotenobject.FieldPath
	Selector() NotificationChannelSpecSlack_FieldPathSelector
	Get(source *NotificationChannelSpec_Slack) []interface{}
	GetSingle(source *NotificationChannelSpec_Slack) (interface{}, bool)
	ClearValue(item *NotificationChannelSpec_Slack)

	// Those methods build corresponding NotificationChannelSpecSlack_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) NotificationChannelSpecSlack_FieldPathValue
	WithIArrayOfValues(values interface{}) NotificationChannelSpecSlack_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) NotificationChannelSpecSlack_FieldPathArrayItemValue
}

type NotificationChannelSpecSlack_FieldPathSelector int32

const (
	NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook NotificationChannelSpecSlack_FieldPathSelector = 0
)

func (s NotificationChannelSpecSlack_FieldPathSelector) String() string {
	switch s {
	case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
		return "incoming_webhook"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", s))
	}
}

func BuildNotificationChannelSpecSlack_FieldPath(fp gotenobject.RawFieldPath) (NotificationChannelSpecSlack_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationChannelSpec_Slack")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "incoming_webhook", "incomingWebhook", "incoming-webhook":
			return &NotificationChannelSpecSlack_FieldTerminalPath{selector: NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationChannelSpec_Slack", fp)
}

func ParseNotificationChannelSpecSlack_FieldPath(rawField string) (NotificationChannelSpecSlack_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationChannelSpecSlack_FieldPath(fp)
}

func MustParseNotificationChannelSpecSlack_FieldPath(rawField string) NotificationChannelSpecSlack_FieldPath {
	fp, err := ParseNotificationChannelSpecSlack_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationChannelSpecSlack_FieldTerminalPath struct {
	selector NotificationChannelSpecSlack_FieldPathSelector
}

var _ NotificationChannelSpecSlack_FieldPath = (*NotificationChannelSpecSlack_FieldTerminalPath)(nil)

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) Selector() NotificationChannelSpecSlack_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *NotificationChannelSpecSlack_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *NotificationChannelSpecSlack_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source NotificationChannelSpec_Slack
func (fp *NotificationChannelSpecSlack_FieldTerminalPath) Get(source *NotificationChannelSpec_Slack) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
			values = append(values, source.IncomingWebhook)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", fp.selector))
		}
	}
	return
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*NotificationChannelSpec_Slack))
}

// GetSingle returns value pointed by specific field of from source NotificationChannelSpec_Slack
func (fp *NotificationChannelSpecSlack_FieldTerminalPath) GetSingle(source *NotificationChannelSpec_Slack) (interface{}, bool) {
	switch fp.selector {
	case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
		return source.GetIncomingWebhook(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*NotificationChannelSpec_Slack))
}

// GetDefault returns a default value of the field type
func (fp *NotificationChannelSpecSlack_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) ClearValue(item *NotificationChannelSpec_Slack) {
	if item != nil {
		switch fp.selector {
		case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
			item.IncomingWebhook = ""
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", fp.selector))
		}
	}
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationChannelSpec_Slack))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationChannelSpecSlack_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) WithIValue(value interface{}) NotificationChannelSpecSlack_FieldPathValue {
	switch fp.selector {
	case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
		return &NotificationChannelSpecSlack_FieldTerminalPathValue{NotificationChannelSpecSlack_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationChannelSpecSlack_FieldPathArrayOfValues {
	fpaov := &NotificationChannelSpecSlack_FieldTerminalPathArrayOfValues{NotificationChannelSpecSlack_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
		return &NotificationChannelSpecSlack_FieldTerminalPathArrayOfValues{NotificationChannelSpecSlack_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", fp.selector))
	}
	return fpaov
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationChannelSpecSlack_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecSlack_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// NotificationChannelSpecSlack_FieldPathValue allows storing values for Slack fields according to their type
type NotificationChannelSpecSlack_FieldPathValue interface {
	NotificationChannelSpecSlack_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationChannelSpec_Slack)
	CompareWith(*NotificationChannelSpec_Slack) (cmp int, comparable bool)
}

func ParseNotificationChannelSpecSlack_FieldPathValue(pathStr, valueStr string) (NotificationChannelSpecSlack_FieldPathValue, error) {
	fp, err := ParseNotificationChannelSpecSlack_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 Slack field path value from %s: %v", valueStr, err)
	}
	return fpv.(NotificationChannelSpecSlack_FieldPathValue), nil
}

func MustParseNotificationChannelSpecSlack_FieldPathValue(pathStr, valueStr string) NotificationChannelSpecSlack_FieldPathValue {
	fpv, err := ParseNotificationChannelSpecSlack_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationChannelSpecSlack_FieldTerminalPathValue struct {
	NotificationChannelSpecSlack_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecSlack_FieldPathValue = (*NotificationChannelSpecSlack_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Slack' as interface{}
func (fpv *NotificationChannelSpecSlack_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationChannelSpecSlack_FieldTerminalPathValue) AsIncomingWebhookValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Slack
func (fpv *NotificationChannelSpecSlack_FieldTerminalPathValue) SetTo(target **NotificationChannelSpec_Slack) {
	if *target == nil {
		*target = new(NotificationChannelSpec_Slack)
	}
	switch fpv.selector {
	case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
		(*target).IncomingWebhook = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecSlack_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*NotificationChannelSpec_Slack)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'NotificationChannelSpecSlack_FieldTerminalPathValue' with the value under path in 'NotificationChannelSpec_Slack'.
func (fpv *NotificationChannelSpecSlack_FieldTerminalPathValue) CompareWith(source *NotificationChannelSpec_Slack) (int, bool) {
	switch fpv.selector {
	case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
		leftValue := fpv.value.(string)
		rightValue := source.GetIncomingWebhook()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Slack: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecSlack_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*NotificationChannelSpec_Slack))
}

// NotificationChannelSpecSlack_FieldPathArrayItemValue allows storing single item in Path-specific values for Slack according to their type
// Present only for array (repeated) types.
type NotificationChannelSpecSlack_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	NotificationChannelSpecSlack_FieldPath
	ContainsValue(*NotificationChannelSpec_Slack) bool
}

// ParseNotificationChannelSpecSlack_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseNotificationChannelSpecSlack_FieldPathArrayItemValue(pathStr, valueStr string) (NotificationChannelSpecSlack_FieldPathArrayItemValue, error) {
	fp, err := ParseNotificationChannelSpecSlack_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 Slack field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(NotificationChannelSpecSlack_FieldPathArrayItemValue), nil
}

func MustParseNotificationChannelSpecSlack_FieldPathArrayItemValue(pathStr, valueStr string) NotificationChannelSpecSlack_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationChannelSpecSlack_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationChannelSpecSlack_FieldTerminalPathArrayItemValue struct {
	NotificationChannelSpecSlack_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecSlack_FieldPathArrayItemValue = (*NotificationChannelSpecSlack_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationChannelSpec_Slack as interface{}
func (fpaiv *NotificationChannelSpecSlack_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *NotificationChannelSpecSlack_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationChannelSpec_Slack) (interface{}, bool) {
	return nil, false
}

func (fpaiv *NotificationChannelSpecSlack_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*NotificationChannelSpec_Slack))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Slack'
func (fpaiv *NotificationChannelSpecSlack_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationChannelSpec_Slack) bool {
	slice := fpaiv.NotificationChannelSpecSlack_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
}

// NotificationChannelSpecSlack_FieldPathArrayOfValues allows storing slice of values for Slack fields according to their type
type NotificationChannelSpecSlack_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationChannelSpecSlack_FieldPath
}

func ParseNotificationChannelSpecSlack_FieldPathArrayOfValues(pathStr, valuesStr string) (NotificationChannelSpecSlack_FieldPathArrayOfValues, error) {
	fp, err := ParseNotificationChannelSpecSlack_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 Slack field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(NotificationChannelSpecSlack_FieldPathArrayOfValues), nil
}

func MustParseNotificationChannelSpecSlack_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationChannelSpecSlack_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationChannelSpecSlack_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationChannelSpecSlack_FieldTerminalPathArrayOfValues struct {
	NotificationChannelSpecSlack_FieldTerminalPath
	values interface{}
}

var _ NotificationChannelSpecSlack_FieldPathArrayOfValues = (*NotificationChannelSpecSlack_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationChannelSpecSlack_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationChannelSpecSlack_FieldPathSelectorIncomingWebhook:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationChannelSpecSlack_FieldTerminalPathArrayOfValues) AsIncomingWebhookArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type NotificationChannelSpecPagerDuty_FieldPath interface {
	gotenobject.FieldPath
	Selector() NotificationChannelSpecPagerDuty_FieldPathSelector
	Get(source *NotificationChannelSpec_PagerDuty) []interface{}
	GetSingle(source *NotificationChannelSpec_PagerDuty) (interface{}, bool)
	ClearValue(item *NotificationChannelSpec_PagerDuty)

	// Those methods build corresponding NotificationChannelSpecPagerDuty_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) NotificationChannelSpecPagerDuty_FieldPathValue
	WithIArrayOfValues(values interface{}) NotificationChannelSpecPagerDuty_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) NotificationChannelSpecPagerDuty_FieldPathArrayItemValue
}

type NotificationChannelSpecPagerDuty_FieldPathSelector int32

const (
	NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey NotificationChannelSpecPagerDuty_FieldPathSelector = 0
)

func (s NotificationChannelSpecPagerDuty_FieldPathSelector) String() string {
	switch s {
	case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
		return "service_key"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", s))
	}
}

func BuildNotificationChannelSpecPagerDuty_FieldPath(fp gotenobject.RawFieldPath) (NotificationChannelSpecPagerDuty_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationChannelSpec_PagerDuty")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service_key", "serviceKey", "service-key":
			return &NotificationChannelSpecPagerDuty_FieldTerminalPath{selector: NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationChannelSpec_PagerDuty", fp)
}

func ParseNotificationChannelSpecPagerDuty_FieldPath(rawField string) (NotificationChannelSpecPagerDuty_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationChannelSpecPagerDuty_FieldPath(fp)
}

func MustParseNotificationChannelSpecPagerDuty_FieldPath(rawField string) NotificationChannelSpecPagerDuty_FieldPath {
	fp, err := ParseNotificationChannelSpecPagerDuty_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationChannelSpecPagerDuty_FieldTerminalPath struct {
	selector NotificationChannelSpecPagerDuty_FieldPathSelector
}

var _ NotificationChannelSpecPagerDuty_FieldPath = (*NotificationChannelSpecPagerDuty_FieldTerminalPath)(nil)

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) Selector() NotificationChannelSpecPagerDuty_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source NotificationChannelSpec_PagerDuty
func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) Get(source *NotificationChannelSpec_PagerDuty) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
			values = append(values, source.ServiceKey)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", fp.selector))
		}
	}
	return
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*NotificationChannelSpec_PagerDuty))
}

// GetSingle returns value pointed by specific field of from source NotificationChannelSpec_PagerDuty
func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) GetSingle(source *NotificationChannelSpec_PagerDuty) (interface{}, bool) {
	switch fp.selector {
	case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
		return source.GetServiceKey(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*NotificationChannelSpec_PagerDuty))
}

// GetDefault returns a default value of the field type
func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) ClearValue(item *NotificationChannelSpec_PagerDuty) {
	if item != nil {
		switch fp.selector {
		case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
			item.ServiceKey = ""
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", fp.selector))
		}
	}
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationChannelSpec_PagerDuty))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) WithIValue(value interface{}) NotificationChannelSpecPagerDuty_FieldPathValue {
	switch fp.selector {
	case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
		return &NotificationChannelSpecPagerDuty_FieldTerminalPathValue{NotificationChannelSpecPagerDuty_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationChannelSpecPagerDuty_FieldPathArrayOfValues {
	fpaov := &NotificationChannelSpecPagerDuty_FieldTerminalPathArrayOfValues{NotificationChannelSpecPagerDuty_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
		return &NotificationChannelSpecPagerDuty_FieldTerminalPathArrayOfValues{NotificationChannelSpecPagerDuty_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", fp.selector))
	}
	return fpaov
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationChannelSpecPagerDuty_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecPagerDuty_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// NotificationChannelSpecPagerDuty_FieldPathValue allows storing values for PagerDuty fields according to their type
type NotificationChannelSpecPagerDuty_FieldPathValue interface {
	NotificationChannelSpecPagerDuty_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationChannelSpec_PagerDuty)
	CompareWith(*NotificationChannelSpec_PagerDuty) (cmp int, comparable bool)
}

func ParseNotificationChannelSpecPagerDuty_FieldPathValue(pathStr, valueStr string) (NotificationChannelSpecPagerDuty_FieldPathValue, error) {
	fp, err := ParseNotificationChannelSpecPagerDuty_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 PagerDuty field path value from %s: %v", valueStr, err)
	}
	return fpv.(NotificationChannelSpecPagerDuty_FieldPathValue), nil
}

func MustParseNotificationChannelSpecPagerDuty_FieldPathValue(pathStr, valueStr string) NotificationChannelSpecPagerDuty_FieldPathValue {
	fpv, err := ParseNotificationChannelSpecPagerDuty_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationChannelSpecPagerDuty_FieldTerminalPathValue struct {
	NotificationChannelSpecPagerDuty_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecPagerDuty_FieldPathValue = (*NotificationChannelSpecPagerDuty_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PagerDuty' as interface{}
func (fpv *NotificationChannelSpecPagerDuty_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationChannelSpecPagerDuty_FieldTerminalPathValue) AsServiceKeyValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object PagerDuty
func (fpv *NotificationChannelSpecPagerDuty_FieldTerminalPathValue) SetTo(target **NotificationChannelSpec_PagerDuty) {
	if *target == nil {
		*target = new(NotificationChannelSpec_PagerDuty)
	}
	switch fpv.selector {
	case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
		(*target).ServiceKey = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecPagerDuty_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*NotificationChannelSpec_PagerDuty)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'NotificationChannelSpecPagerDuty_FieldTerminalPathValue' with the value under path in 'NotificationChannelSpec_PagerDuty'.
func (fpv *NotificationChannelSpecPagerDuty_FieldTerminalPathValue) CompareWith(source *NotificationChannelSpec_PagerDuty) (int, bool) {
	switch fpv.selector {
	case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
		leftValue := fpv.value.(string)
		rightValue := source.GetServiceKey()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_PagerDuty: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecPagerDuty_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*NotificationChannelSpec_PagerDuty))
}

// NotificationChannelSpecPagerDuty_FieldPathArrayItemValue allows storing single item in Path-specific values for PagerDuty according to their type
// Present only for array (repeated) types.
type NotificationChannelSpecPagerDuty_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	NotificationChannelSpecPagerDuty_FieldPath
	ContainsValue(*NotificationChannelSpec_PagerDuty) bool
}

// ParseNotificationChannelSpecPagerDuty_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseNotificationChannelSpecPagerDuty_FieldPathArrayItemValue(pathStr, valueStr string) (NotificationChannelSpecPagerDuty_FieldPathArrayItemValue, error) {
	fp, err := ParseNotificationChannelSpecPagerDuty_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 PagerDuty field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(NotificationChannelSpecPagerDuty_FieldPathArrayItemValue), nil
}

func MustParseNotificationChannelSpecPagerDuty_FieldPathArrayItemValue(pathStr, valueStr string) NotificationChannelSpecPagerDuty_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationChannelSpecPagerDuty_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationChannelSpecPagerDuty_FieldTerminalPathArrayItemValue struct {
	NotificationChannelSpecPagerDuty_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecPagerDuty_FieldPathArrayItemValue = (*NotificationChannelSpecPagerDuty_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationChannelSpec_PagerDuty as interface{}
func (fpaiv *NotificationChannelSpecPagerDuty_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *NotificationChannelSpecPagerDuty_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationChannelSpec_PagerDuty) (interface{}, bool) {
	return nil, false
}

func (fpaiv *NotificationChannelSpecPagerDuty_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*NotificationChannelSpec_PagerDuty))
}

// Contains returns a boolean indicating if value that is being held is present in given 'PagerDuty'
func (fpaiv *NotificationChannelSpecPagerDuty_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationChannelSpec_PagerDuty) bool {
	slice := fpaiv.NotificationChannelSpecPagerDuty_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
}

// NotificationChannelSpecPagerDuty_FieldPathArrayOfValues allows storing slice of values for PagerDuty fields according to their type
type NotificationChannelSpecPagerDuty_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationChannelSpecPagerDuty_FieldPath
}

func ParseNotificationChannelSpecPagerDuty_FieldPathArrayOfValues(pathStr, valuesStr string) (NotificationChannelSpecPagerDuty_FieldPathArrayOfValues, error) {
	fp, err := ParseNotificationChannelSpecPagerDuty_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 PagerDuty field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(NotificationChannelSpecPagerDuty_FieldPathArrayOfValues), nil
}

func MustParseNotificationChannelSpecPagerDuty_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationChannelSpecPagerDuty_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationChannelSpecPagerDuty_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationChannelSpecPagerDuty_FieldTerminalPathArrayOfValues struct {
	NotificationChannelSpecPagerDuty_FieldTerminalPath
	values interface{}
}

var _ NotificationChannelSpecPagerDuty_FieldPathArrayOfValues = (*NotificationChannelSpecPagerDuty_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationChannelSpecPagerDuty_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationChannelSpecPagerDuty_FieldPathSelectorServiceKey:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationChannelSpecPagerDuty_FieldTerminalPathArrayOfValues) AsServiceKeyArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type NotificationChannelSpecWebhook_FieldPath interface {
	gotenobject.FieldPath
	Selector() NotificationChannelSpecWebhook_FieldPathSelector
	Get(source *NotificationChannelSpec_Webhook) []interface{}
	GetSingle(source *NotificationChannelSpec_Webhook) (interface{}, bool)
	ClearValue(item *NotificationChannelSpec_Webhook)

	// Those methods build corresponding NotificationChannelSpecWebhook_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) NotificationChannelSpecWebhook_FieldPathValue
	WithIArrayOfValues(values interface{}) NotificationChannelSpecWebhook_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) NotificationChannelSpecWebhook_FieldPathArrayItemValue
}

type NotificationChannelSpecWebhook_FieldPathSelector int32

const (
	NotificationChannelSpecWebhook_FieldPathSelectorUrl              NotificationChannelSpecWebhook_FieldPathSelector = 0
	NotificationChannelSpecWebhook_FieldPathSelectorHeaders          NotificationChannelSpecWebhook_FieldPathSelector = 1
	NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb NotificationChannelSpecWebhook_FieldPathSelector = 2
)

func (s NotificationChannelSpecWebhook_FieldPathSelector) String() string {
	switch s {
	case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
		return "url"
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		return "headers"
	case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
		return "max_message_size_mb"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", s))
	}
}

func BuildNotificationChannelSpecWebhook_FieldPath(fp gotenobject.RawFieldPath) (NotificationChannelSpecWebhook_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationChannelSpec_Webhook")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "url":
			return &NotificationChannelSpecWebhook_FieldTerminalPath{selector: NotificationChannelSpecWebhook_FieldPathSelectorUrl}, nil
		case "headers":
			return &NotificationChannelSpecWebhook_FieldTerminalPath{selector: NotificationChannelSpecWebhook_FieldPathSelectorHeaders}, nil
		case "max_message_size_mb", "maxMessageSizeMb", "max-message-size-mb":
			return &NotificationChannelSpecWebhook_FieldTerminalPath{selector: NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb}, nil
		}
	} else {
		switch fp[0] {
		case "headers":
			if subpath, err := BuildNotificationChannelSpecWebhookHeader_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationChannelSpecWebhook_FieldSubPath{selector: NotificationChannelSpecWebhook_FieldPathSelectorHeaders, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationChannelSpec_Webhook", fp)
}

func ParseNotificationChannelSpecWebhook_FieldPath(rawField string) (NotificationChannelSpecWebhook_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationChannelSpecWebhook_FieldPath(fp)
}

func MustParseNotificationChannelSpecWebhook_FieldPath(rawField string) NotificationChannelSpecWebhook_FieldPath {
	fp, err := ParseNotificationChannelSpecWebhook_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationChannelSpecWebhook_FieldTerminalPath struct {
	selector NotificationChannelSpecWebhook_FieldPathSelector
}

var _ NotificationChannelSpecWebhook_FieldPath = (*NotificationChannelSpecWebhook_FieldTerminalPath)(nil)

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) Selector() NotificationChannelSpecWebhook_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source NotificationChannelSpec_Webhook
func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) Get(source *NotificationChannelSpec_Webhook) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
			values = append(values, source.Url)
		case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
			for _, value := range source.GetHeaders() {
				values = append(values, value)
			}
		case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
			values = append(values, source.MaxMessageSizeMb)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fp.selector))
		}
	}
	return
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*NotificationChannelSpec_Webhook))
}

// GetSingle returns value pointed by specific field of from source NotificationChannelSpec_Webhook
func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) GetSingle(source *NotificationChannelSpec_Webhook) (interface{}, bool) {
	switch fp.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
		return source.GetUrl(), source != nil
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		res := source.GetHeaders()
		return res, res != nil
	case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
		return source.GetMaxMessageSizeMb(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*NotificationChannelSpec_Webhook))
}

// GetDefault returns a default value of the field type
func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
		return ""
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		return ([]*NotificationChannelSpec_Webhook_Header)(nil)
	case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
		return float64(0)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) ClearValue(item *NotificationChannelSpec_Webhook) {
	if item != nil {
		switch fp.selector {
		case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
			item.Url = ""
		case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
			item.Headers = nil
		case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
			item.MaxMessageSizeMb = float64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fp.selector))
		}
	}
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationChannelSpec_Webhook))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationChannelSpecWebhook_FieldPathSelectorUrl ||
		fp.selector == NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) WithIValue(value interface{}) NotificationChannelSpecWebhook_FieldPathValue {
	switch fp.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
		return &NotificationChannelSpecWebhook_FieldTerminalPathValue{NotificationChannelSpecWebhook_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		return &NotificationChannelSpecWebhook_FieldTerminalPathValue{NotificationChannelSpecWebhook_FieldTerminalPath: *fp, value: value.([]*NotificationChannelSpec_Webhook_Header)}
	case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
		return &NotificationChannelSpecWebhook_FieldTerminalPathValue{NotificationChannelSpecWebhook_FieldTerminalPath: *fp, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationChannelSpecWebhook_FieldPathArrayOfValues {
	fpaov := &NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues{NotificationChannelSpecWebhook_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
		return &NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues{NotificationChannelSpecWebhook_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		return &NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues{NotificationChannelSpecWebhook_FieldTerminalPath: *fp, values: values.([][]*NotificationChannelSpec_Webhook_Header)}
	case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
		return &NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues{NotificationChannelSpecWebhook_FieldTerminalPath: *fp, values: values.([]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fp.selector))
	}
	return fpaov
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationChannelSpecWebhook_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		return &NotificationChannelSpecWebhook_FieldTerminalPathArrayItemValue{NotificationChannelSpecWebhook_FieldTerminalPath: *fp, value: value.(*NotificationChannelSpec_Webhook_Header)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecWebhook_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type NotificationChannelSpecWebhook_FieldSubPath struct {
	selector NotificationChannelSpecWebhook_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationChannelSpecWebhook_FieldPath = (*NotificationChannelSpecWebhook_FieldSubPath)(nil)

func (fps *NotificationChannelSpecWebhook_FieldSubPath) Selector() NotificationChannelSpecWebhook_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationChannelSpecWebhook_FieldSubPath) AsHeadersSubPath() (NotificationChannelSpecWebhookHeader_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationChannelSpecWebhookHeader_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *NotificationChannelSpecWebhook_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *NotificationChannelSpecWebhook_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source NotificationChannelSpec_Webhook
func (fps *NotificationChannelSpecWebhook_FieldSubPath) Get(source *NotificationChannelSpec_Webhook) (values []interface{}) {
	switch fps.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		for _, item := range source.GetHeaders() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fps.selector))
	}
	return
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*NotificationChannelSpec_Webhook))
}

// GetSingle returns value of selected field from source NotificationChannelSpec_Webhook
func (fps *NotificationChannelSpecWebhook_FieldSubPath) GetSingle(source *NotificationChannelSpec_Webhook) (interface{}, bool) {
	switch fps.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		if len(source.GetHeaders()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetHeaders()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fps.selector))
	}
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*NotificationChannelSpec_Webhook))
}

// GetDefault returns a default value of the field type
func (fps *NotificationChannelSpecWebhook_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) ClearValue(item *NotificationChannelSpec_Webhook) {
	if item != nil {
		switch fps.selector {
		case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
			for _, subItem := range item.Headers {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fps.selector))
		}
	}
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationChannelSpec_Webhook))
}

// IsLeaf - whether field path is holds simple value
func (fps *NotificationChannelSpecWebhook_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&NotificationChannelSpecWebhook_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) WithIValue(value interface{}) NotificationChannelSpecWebhook_FieldPathValue {
	return &NotificationChannelSpecWebhook_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationChannelSpecWebhook_FieldPathArrayOfValues {
	return &NotificationChannelSpecWebhook_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationChannelSpecWebhook_FieldPathArrayItemValue {
	return &NotificationChannelSpecWebhook_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *NotificationChannelSpecWebhook_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// NotificationChannelSpecWebhook_FieldPathValue allows storing values for Webhook fields according to their type
type NotificationChannelSpecWebhook_FieldPathValue interface {
	NotificationChannelSpecWebhook_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationChannelSpec_Webhook)
	CompareWith(*NotificationChannelSpec_Webhook) (cmp int, comparable bool)
}

func ParseNotificationChannelSpecWebhook_FieldPathValue(pathStr, valueStr string) (NotificationChannelSpecWebhook_FieldPathValue, error) {
	fp, err := ParseNotificationChannelSpecWebhook_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 Webhook field path value from %s: %v", valueStr, err)
	}
	return fpv.(NotificationChannelSpecWebhook_FieldPathValue), nil
}

func MustParseNotificationChannelSpecWebhook_FieldPathValue(pathStr, valueStr string) NotificationChannelSpecWebhook_FieldPathValue {
	fpv, err := ParseNotificationChannelSpecWebhook_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationChannelSpecWebhook_FieldTerminalPathValue struct {
	NotificationChannelSpecWebhook_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecWebhook_FieldPathValue = (*NotificationChannelSpecWebhook_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Webhook' as interface{}
func (fpv *NotificationChannelSpecWebhook_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationChannelSpecWebhook_FieldTerminalPathValue) AsUrlValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationChannelSpecWebhook_FieldTerminalPathValue) AsHeadersValue() ([]*NotificationChannelSpec_Webhook_Header, bool) {
	res, ok := fpv.value.([]*NotificationChannelSpec_Webhook_Header)
	return res, ok
}
func (fpv *NotificationChannelSpecWebhook_FieldTerminalPathValue) AsMaxMessageSizeMbValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}

// SetTo stores value for selected field for object Webhook
func (fpv *NotificationChannelSpecWebhook_FieldTerminalPathValue) SetTo(target **NotificationChannelSpec_Webhook) {
	if *target == nil {
		*target = new(NotificationChannelSpec_Webhook)
	}
	switch fpv.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
		(*target).Url = fpv.value.(string)
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		(*target).Headers = fpv.value.([]*NotificationChannelSpec_Webhook_Header)
	case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
		(*target).MaxMessageSizeMb = fpv.value.(float64)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecWebhook_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*NotificationChannelSpec_Webhook)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'NotificationChannelSpecWebhook_FieldTerminalPathValue' with the value under path in 'NotificationChannelSpec_Webhook'.
func (fpv *NotificationChannelSpecWebhook_FieldTerminalPathValue) CompareWith(source *NotificationChannelSpec_Webhook) (int, bool) {
	switch fpv.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
		leftValue := fpv.value.(string)
		rightValue := source.GetUrl()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		return 0, false
	case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
		leftValue := fpv.value.(float64)
		rightValue := source.GetMaxMessageSizeMb()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecWebhook_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*NotificationChannelSpec_Webhook))
}

type NotificationChannelSpecWebhook_FieldSubPathValue struct {
	NotificationChannelSpecWebhook_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationChannelSpecWebhook_FieldPathValue = (*NotificationChannelSpecWebhook_FieldSubPathValue)(nil)

func (fpvs *NotificationChannelSpecWebhook_FieldSubPathValue) AsHeadersPathValue() (NotificationChannelSpecWebhookHeader_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationChannelSpecWebhookHeader_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationChannelSpecWebhook_FieldSubPathValue) SetTo(target **NotificationChannelSpec_Webhook) {
	if *target == nil {
		*target = new(NotificationChannelSpec_Webhook)
	}
	switch fpvs.Selector() {
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fpvs.Selector()))
	}
}

func (fpvs *NotificationChannelSpecWebhook_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*NotificationChannelSpec_Webhook)
	fpvs.SetTo(&typedObject)
}

func (fpvs *NotificationChannelSpecWebhook_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *NotificationChannelSpecWebhook_FieldSubPathValue) CompareWith(source *NotificationChannelSpec_Webhook) (int, bool) {
	switch fpvs.Selector() {
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fpvs.Selector()))
	}
}

func (fpvs *NotificationChannelSpecWebhook_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*NotificationChannelSpec_Webhook))
}

// NotificationChannelSpecWebhook_FieldPathArrayItemValue allows storing single item in Path-specific values for Webhook according to their type
// Present only for array (repeated) types.
type NotificationChannelSpecWebhook_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	NotificationChannelSpecWebhook_FieldPath
	ContainsValue(*NotificationChannelSpec_Webhook) bool
}

// ParseNotificationChannelSpecWebhook_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseNotificationChannelSpecWebhook_FieldPathArrayItemValue(pathStr, valueStr string) (NotificationChannelSpecWebhook_FieldPathArrayItemValue, error) {
	fp, err := ParseNotificationChannelSpecWebhook_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 Webhook field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(NotificationChannelSpecWebhook_FieldPathArrayItemValue), nil
}

func MustParseNotificationChannelSpecWebhook_FieldPathArrayItemValue(pathStr, valueStr string) NotificationChannelSpecWebhook_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationChannelSpecWebhook_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationChannelSpecWebhook_FieldTerminalPathArrayItemValue struct {
	NotificationChannelSpecWebhook_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecWebhook_FieldPathArrayItemValue = (*NotificationChannelSpecWebhook_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationChannelSpec_Webhook as interface{}
func (fpaiv *NotificationChannelSpecWebhook_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *NotificationChannelSpecWebhook_FieldTerminalPathArrayItemValue) AsHeadersItemValue() (*NotificationChannelSpec_Webhook_Header, bool) {
	res, ok := fpaiv.value.(*NotificationChannelSpec_Webhook_Header)
	return res, ok
}

func (fpaiv *NotificationChannelSpecWebhook_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationChannelSpec_Webhook) (interface{}, bool) {
	return nil, false
}

func (fpaiv *NotificationChannelSpecWebhook_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*NotificationChannelSpec_Webhook))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Webhook'
func (fpaiv *NotificationChannelSpecWebhook_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationChannelSpec_Webhook) bool {
	slice := fpaiv.NotificationChannelSpecWebhook_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 NotificationChannelSpecWebhook_FieldSubPathArrayItemValue struct {
	NotificationChannelSpecWebhook_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *NotificationChannelSpecWebhook_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationChannelSpecWebhook_FieldSubPathArrayItemValue) AsHeadersPathItemValue() (NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Webhook'
func (fpaivs *NotificationChannelSpecWebhook_FieldSubPathArrayItemValue) ContainsValue(source *NotificationChannelSpec_Webhook) bool {
	switch fpaivs.Selector() {
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook: %d", fpaivs.Selector()))
	}
}

// NotificationChannelSpecWebhook_FieldPathArrayOfValues allows storing slice of values for Webhook fields according to their type
type NotificationChannelSpecWebhook_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationChannelSpecWebhook_FieldPath
}

func ParseNotificationChannelSpecWebhook_FieldPathArrayOfValues(pathStr, valuesStr string) (NotificationChannelSpecWebhook_FieldPathArrayOfValues, error) {
	fp, err := ParseNotificationChannelSpecWebhook_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 Webhook field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(NotificationChannelSpecWebhook_FieldPathArrayOfValues), nil
}

func MustParseNotificationChannelSpecWebhook_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationChannelSpecWebhook_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationChannelSpecWebhook_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues struct {
	NotificationChannelSpecWebhook_FieldTerminalPath
	values interface{}
}

var _ NotificationChannelSpecWebhook_FieldPathArrayOfValues = (*NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationChannelSpecWebhook_FieldPathSelectorUrl:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationChannelSpecWebhook_FieldPathSelectorHeaders:
		for _, v := range fpaov.values.([][]*NotificationChannelSpec_Webhook_Header) {
			values = append(values, v)
		}
	case NotificationChannelSpecWebhook_FieldPathSelectorMaxMessageSizeMb:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues) AsUrlArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues) AsHeadersArrayOfValues() ([][]*NotificationChannelSpec_Webhook_Header, bool) {
	res, ok := fpaov.values.([][]*NotificationChannelSpec_Webhook_Header)
	return res, ok
}
func (fpaov *NotificationChannelSpecWebhook_FieldTerminalPathArrayOfValues) AsMaxMessageSizeMbArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}

type NotificationChannelSpecWebhook_FieldSubPathArrayOfValues struct {
	NotificationChannelSpecWebhook_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationChannelSpecWebhook_FieldPathArrayOfValues = (*NotificationChannelSpecWebhook_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationChannelSpecWebhook_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationChannelSpecWebhook_FieldSubPathArrayOfValues) AsHeadersPathArrayOfValues() (NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type NotificationChannelSpecWebhookHeader_FieldPath interface {
	gotenobject.FieldPath
	Selector() NotificationChannelSpecWebhookHeader_FieldPathSelector
	Get(source *NotificationChannelSpec_Webhook_Header) []interface{}
	GetSingle(source *NotificationChannelSpec_Webhook_Header) (interface{}, bool)
	ClearValue(item *NotificationChannelSpec_Webhook_Header)

	// Those methods build corresponding NotificationChannelSpecWebhookHeader_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) NotificationChannelSpecWebhookHeader_FieldPathValue
	WithIArrayOfValues(values interface{}) NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue
}

type NotificationChannelSpecWebhookHeader_FieldPathSelector int32

const (
	NotificationChannelSpecWebhookHeader_FieldPathSelectorKey   NotificationChannelSpecWebhookHeader_FieldPathSelector = 0
	NotificationChannelSpecWebhookHeader_FieldPathSelectorValue NotificationChannelSpecWebhookHeader_FieldPathSelector = 1
)

func (s NotificationChannelSpecWebhookHeader_FieldPathSelector) String() string {
	switch s {
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
		return "key"
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
		return "value"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook_Header: %d", s))
	}
}

func BuildNotificationChannelSpecWebhookHeader_FieldPath(fp gotenobject.RawFieldPath) (NotificationChannelSpecWebhookHeader_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationChannelSpec_Webhook_Header")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "key":
			return &NotificationChannelSpecWebhookHeader_FieldTerminalPath{selector: NotificationChannelSpecWebhookHeader_FieldPathSelectorKey}, nil
		case "value":
			return &NotificationChannelSpecWebhookHeader_FieldTerminalPath{selector: NotificationChannelSpecWebhookHeader_FieldPathSelectorValue}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationChannelSpec_Webhook_Header", fp)
}

func ParseNotificationChannelSpecWebhookHeader_FieldPath(rawField string) (NotificationChannelSpecWebhookHeader_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationChannelSpecWebhookHeader_FieldPath(fp)
}

func MustParseNotificationChannelSpecWebhookHeader_FieldPath(rawField string) NotificationChannelSpecWebhookHeader_FieldPath {
	fp, err := ParseNotificationChannelSpecWebhookHeader_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationChannelSpecWebhookHeader_FieldTerminalPath struct {
	selector NotificationChannelSpecWebhookHeader_FieldPathSelector
}

var _ NotificationChannelSpecWebhookHeader_FieldPath = (*NotificationChannelSpecWebhookHeader_FieldTerminalPath)(nil)

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) Selector() NotificationChannelSpecWebhookHeader_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source NotificationChannelSpec_Webhook_Header
func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) Get(source *NotificationChannelSpec_Webhook_Header) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
			values = append(values, source.Key)
		case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
			values = append(values, source.Value)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook_Header: %d", fp.selector))
		}
	}
	return
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*NotificationChannelSpec_Webhook_Header))
}

// GetSingle returns value pointed by specific field of from source NotificationChannelSpec_Webhook_Header
func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) GetSingle(source *NotificationChannelSpec_Webhook_Header) (interface{}, bool) {
	switch fp.selector {
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
		return source.GetKey(), source != nil
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
		return source.GetValue(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook_Header: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*NotificationChannelSpec_Webhook_Header))
}

// GetDefault returns a default value of the field type
func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
		return ""
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook_Header: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) ClearValue(item *NotificationChannelSpec_Webhook_Header) {
	if item != nil {
		switch fp.selector {
		case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
			item.Key = ""
		case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
			item.Value = ""
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook_Header: %d", fp.selector))
		}
	}
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationChannelSpec_Webhook_Header))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationChannelSpecWebhookHeader_FieldPathSelectorKey ||
		fp.selector == NotificationChannelSpecWebhookHeader_FieldPathSelectorValue
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) WithIValue(value interface{}) NotificationChannelSpecWebhookHeader_FieldPathValue {
	switch fp.selector {
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
		return &NotificationChannelSpecWebhookHeader_FieldTerminalPathValue{NotificationChannelSpecWebhookHeader_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
		return &NotificationChannelSpecWebhookHeader_FieldTerminalPathValue{NotificationChannelSpecWebhookHeader_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook_Header: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues {
	fpaov := &NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayOfValues{NotificationChannelSpecWebhookHeader_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
		return &NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayOfValues{NotificationChannelSpecWebhookHeader_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
		return &NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayOfValues{NotificationChannelSpecWebhookHeader_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook_Header: %d", fp.selector))
	}
	return fpaov
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook_Header: %d", fp.selector))
	}
}

func (fp *NotificationChannelSpecWebhookHeader_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// NotificationChannelSpecWebhookHeader_FieldPathValue allows storing values for Header fields according to their type
type NotificationChannelSpecWebhookHeader_FieldPathValue interface {
	NotificationChannelSpecWebhookHeader_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationChannelSpec_Webhook_Header)
	CompareWith(*NotificationChannelSpec_Webhook_Header) (cmp int, comparable bool)
}

func ParseNotificationChannelSpecWebhookHeader_FieldPathValue(pathStr, valueStr string) (NotificationChannelSpecWebhookHeader_FieldPathValue, error) {
	fp, err := ParseNotificationChannelSpecWebhookHeader_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 Header field path value from %s: %v", valueStr, err)
	}
	return fpv.(NotificationChannelSpecWebhookHeader_FieldPathValue), nil
}

func MustParseNotificationChannelSpecWebhookHeader_FieldPathValue(pathStr, valueStr string) NotificationChannelSpecWebhookHeader_FieldPathValue {
	fpv, err := ParseNotificationChannelSpecWebhookHeader_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationChannelSpecWebhookHeader_FieldTerminalPathValue struct {
	NotificationChannelSpecWebhookHeader_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecWebhookHeader_FieldPathValue = (*NotificationChannelSpecWebhookHeader_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Header' as interface{}
func (fpv *NotificationChannelSpecWebhookHeader_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationChannelSpecWebhookHeader_FieldTerminalPathValue) AsKeyValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationChannelSpecWebhookHeader_FieldTerminalPathValue) AsValueValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Header
func (fpv *NotificationChannelSpecWebhookHeader_FieldTerminalPathValue) SetTo(target **NotificationChannelSpec_Webhook_Header) {
	if *target == nil {
		*target = new(NotificationChannelSpec_Webhook_Header)
	}
	switch fpv.selector {
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
		(*target).Key = fpv.value.(string)
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
		(*target).Value = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationChannelSpec_Webhook_Header: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecWebhookHeader_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*NotificationChannelSpec_Webhook_Header)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'NotificationChannelSpecWebhookHeader_FieldTerminalPathValue' with the value under path in 'NotificationChannelSpec_Webhook_Header'.
func (fpv *NotificationChannelSpecWebhookHeader_FieldTerminalPathValue) CompareWith(source *NotificationChannelSpec_Webhook_Header) (int, bool) {
	switch fpv.selector {
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
		leftValue := fpv.value.(string)
		rightValue := source.GetKey()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
		leftValue := fpv.value.(string)
		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 NotificationChannelSpec_Webhook_Header: %d", fpv.selector))
	}
}

func (fpv *NotificationChannelSpecWebhookHeader_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*NotificationChannelSpec_Webhook_Header))
}

// NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue allows storing single item in Path-specific values for Header according to their type
// Present only for array (repeated) types.
type NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	NotificationChannelSpecWebhookHeader_FieldPath
	ContainsValue(*NotificationChannelSpec_Webhook_Header) bool
}

// ParseNotificationChannelSpecWebhookHeader_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseNotificationChannelSpecWebhookHeader_FieldPathArrayItemValue(pathStr, valueStr string) (NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue, error) {
	fp, err := ParseNotificationChannelSpecWebhookHeader_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 Header field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue), nil
}

func MustParseNotificationChannelSpecWebhookHeader_FieldPathArrayItemValue(pathStr, valueStr string) NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationChannelSpecWebhookHeader_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayItemValue struct {
	NotificationChannelSpecWebhookHeader_FieldTerminalPath
	value interface{}
}

var _ NotificationChannelSpecWebhookHeader_FieldPathArrayItemValue = (*NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationChannelSpec_Webhook_Header as interface{}
func (fpaiv *NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationChannelSpec_Webhook_Header) (interface{}, bool) {
	return nil, false
}

func (fpaiv *NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*NotificationChannelSpec_Webhook_Header))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Header'
func (fpaiv *NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationChannelSpec_Webhook_Header) bool {
	slice := fpaiv.NotificationChannelSpecWebhookHeader_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
}

// NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues allows storing slice of values for Header fields according to their type
type NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationChannelSpecWebhookHeader_FieldPath
}

func ParseNotificationChannelSpecWebhookHeader_FieldPathArrayOfValues(pathStr, valuesStr string) (NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues, error) {
	fp, err := ParseNotificationChannelSpecWebhookHeader_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 Header field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues), nil
}

func MustParseNotificationChannelSpecWebhookHeader_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationChannelSpecWebhookHeader_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayOfValues struct {
	NotificationChannelSpecWebhookHeader_FieldTerminalPath
	values interface{}
}

var _ NotificationChannelSpecWebhookHeader_FieldPathArrayOfValues = (*NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorKey:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationChannelSpecWebhookHeader_FieldPathSelectorValue:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayOfValues) AsKeyArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationChannelSpecWebhookHeader_FieldTerminalPathArrayOfValues) AsValueArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type AlertingThreshold_FieldPath interface {
	gotenobject.FieldPath
	Selector() AlertingThreshold_FieldPathSelector
	Get(source *AlertingThreshold) []interface{}
	GetSingle(source *AlertingThreshold) (interface{}, bool)
	ClearValue(item *AlertingThreshold)

	// Those methods build corresponding AlertingThreshold_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) AlertingThreshold_FieldPathValue
	WithIArrayOfValues(values interface{}) AlertingThreshold_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) AlertingThreshold_FieldPathArrayItemValue
}

type AlertingThreshold_FieldPathSelector int32

const (
	AlertingThreshold_FieldPathSelectorValue       AlertingThreshold_FieldPathSelector = 0
	AlertingThreshold_FieldPathSelectorIsInclusive AlertingThreshold_FieldPathSelector = 1
)

func (s AlertingThreshold_FieldPathSelector) String() string {
	switch s {
	case AlertingThreshold_FieldPathSelectorValue:
		return "value"
	case AlertingThreshold_FieldPathSelectorIsInclusive:
		return "is_inclusive"
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", s))
	}
}

func BuildAlertingThreshold_FieldPath(fp gotenobject.RawFieldPath) (AlertingThreshold_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AlertingThreshold")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "value":
			return &AlertingThreshold_FieldTerminalPath{selector: AlertingThreshold_FieldPathSelectorValue}, nil
		case "is_inclusive", "isInclusive", "is-inclusive":
			return &AlertingThreshold_FieldTerminalPath{selector: AlertingThreshold_FieldPathSelectorIsInclusive}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AlertingThreshold", fp)
}

func ParseAlertingThreshold_FieldPath(rawField string) (AlertingThreshold_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertingThreshold_FieldPath(fp)
}

func MustParseAlertingThreshold_FieldPath(rawField string) AlertingThreshold_FieldPath {
	fp, err := ParseAlertingThreshold_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertingThreshold_FieldTerminalPath struct {
	selector AlertingThreshold_FieldPathSelector
}

var _ AlertingThreshold_FieldPath = (*AlertingThreshold_FieldTerminalPath)(nil)

func (fp *AlertingThreshold_FieldTerminalPath) Selector() AlertingThreshold_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *AlertingThreshold_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *AlertingThreshold_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source AlertingThreshold
func (fp *AlertingThreshold_FieldTerminalPath) Get(source *AlertingThreshold) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case AlertingThreshold_FieldPathSelectorValue:
			values = append(values, source.Value)
		case AlertingThreshold_FieldPathSelectorIsInclusive:
			values = append(values, source.IsInclusive)
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", fp.selector))
		}
	}
	return
}

func (fp *AlertingThreshold_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*AlertingThreshold))
}

// GetSingle returns value pointed by specific field of from source AlertingThreshold
func (fp *AlertingThreshold_FieldTerminalPath) GetSingle(source *AlertingThreshold) (interface{}, bool) {
	switch fp.selector {
	case AlertingThreshold_FieldPathSelectorValue:
		return source.GetValue(), source != nil
	case AlertingThreshold_FieldPathSelectorIsInclusive:
		return source.GetIsInclusive(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", fp.selector))
	}
}

func (fp *AlertingThreshold_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*AlertingThreshold))
}

// GetDefault returns a default value of the field type
func (fp *AlertingThreshold_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertingThreshold_FieldPathSelectorValue:
		return float64(0)
	case AlertingThreshold_FieldPathSelectorIsInclusive:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", fp.selector))
	}
}

func (fp *AlertingThreshold_FieldTerminalPath) ClearValue(item *AlertingThreshold) {
	if item != nil {
		switch fp.selector {
		case AlertingThreshold_FieldPathSelectorValue:
			item.Value = float64(0)
		case AlertingThreshold_FieldPathSelectorIsInclusive:
			item.IsInclusive = false
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", fp.selector))
		}
	}
}

func (fp *AlertingThreshold_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AlertingThreshold))
}

// IsLeaf - whether field path is holds simple value
func (fp *AlertingThreshold_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == AlertingThreshold_FieldPathSelectorValue ||
		fp.selector == AlertingThreshold_FieldPathSelectorIsInclusive
}

func (fp *AlertingThreshold_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *AlertingThreshold_FieldTerminalPath) WithIValue(value interface{}) AlertingThreshold_FieldPathValue {
	switch fp.selector {
	case AlertingThreshold_FieldPathSelectorValue:
		return &AlertingThreshold_FieldTerminalPathValue{AlertingThreshold_FieldTerminalPath: *fp, value: value.(float64)}
	case AlertingThreshold_FieldPathSelectorIsInclusive:
		return &AlertingThreshold_FieldTerminalPathValue{AlertingThreshold_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", fp.selector))
	}
}

func (fp *AlertingThreshold_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *AlertingThreshold_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingThreshold_FieldPathArrayOfValues {
	fpaov := &AlertingThreshold_FieldTerminalPathArrayOfValues{AlertingThreshold_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertingThreshold_FieldPathSelectorValue:
		return &AlertingThreshold_FieldTerminalPathArrayOfValues{AlertingThreshold_FieldTerminalPath: *fp, values: values.([]float64)}
	case AlertingThreshold_FieldPathSelectorIsInclusive:
		return &AlertingThreshold_FieldTerminalPathArrayOfValues{AlertingThreshold_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", fp.selector))
	}
	return fpaov
}

func (fp *AlertingThreshold_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *AlertingThreshold_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertingThreshold_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", fp.selector))
	}
}

func (fp *AlertingThreshold_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// AlertingThreshold_FieldPathValue allows storing values for AlertingThreshold fields according to their type
type AlertingThreshold_FieldPathValue interface {
	AlertingThreshold_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **AlertingThreshold)
	CompareWith(*AlertingThreshold) (cmp int, comparable bool)
}

func ParseAlertingThreshold_FieldPathValue(pathStr, valueStr string) (AlertingThreshold_FieldPathValue, error) {
	fp, err := ParseAlertingThreshold_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 AlertingThreshold field path value from %s: %v", valueStr, err)
	}
	return fpv.(AlertingThreshold_FieldPathValue), nil
}

func MustParseAlertingThreshold_FieldPathValue(pathStr, valueStr string) AlertingThreshold_FieldPathValue {
	fpv, err := ParseAlertingThreshold_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertingThreshold_FieldTerminalPathValue struct {
	AlertingThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertingThreshold_FieldPathValue = (*AlertingThreshold_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AlertingThreshold' as interface{}
func (fpv *AlertingThreshold_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertingThreshold_FieldTerminalPathValue) AsValueValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}
func (fpv *AlertingThreshold_FieldTerminalPathValue) AsIsInclusiveValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object AlertingThreshold
func (fpv *AlertingThreshold_FieldTerminalPathValue) SetTo(target **AlertingThreshold) {
	if *target == nil {
		*target = new(AlertingThreshold)
	}
	switch fpv.selector {
	case AlertingThreshold_FieldPathSelectorValue:
		(*target).Value = fpv.value.(float64)
	case AlertingThreshold_FieldPathSelectorIsInclusive:
		(*target).IsInclusive = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", fpv.selector))
	}
}

func (fpv *AlertingThreshold_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*AlertingThreshold)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'AlertingThreshold_FieldTerminalPathValue' with the value under path in 'AlertingThreshold'.
func (fpv *AlertingThreshold_FieldTerminalPathValue) CompareWith(source *AlertingThreshold) (int, bool) {
	switch fpv.selector {
	case AlertingThreshold_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
		}
	case AlertingThreshold_FieldPathSelectorIsInclusive:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsInclusive()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingThreshold: %d", fpv.selector))
	}
}

func (fpv *AlertingThreshold_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*AlertingThreshold))
}

// AlertingThreshold_FieldPathArrayItemValue allows storing single item in Path-specific values for AlertingThreshold according to their type
// Present only for array (repeated) types.
type AlertingThreshold_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	AlertingThreshold_FieldPath
	ContainsValue(*AlertingThreshold) bool
}

// ParseAlertingThreshold_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseAlertingThreshold_FieldPathArrayItemValue(pathStr, valueStr string) (AlertingThreshold_FieldPathArrayItemValue, error) {
	fp, err := ParseAlertingThreshold_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 AlertingThreshold field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(AlertingThreshold_FieldPathArrayItemValue), nil
}

func MustParseAlertingThreshold_FieldPathArrayItemValue(pathStr, valueStr string) AlertingThreshold_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertingThreshold_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertingThreshold_FieldTerminalPathArrayItemValue struct {
	AlertingThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertingThreshold_FieldPathArrayItemValue = (*AlertingThreshold_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object AlertingThreshold as interface{}
func (fpaiv *AlertingThreshold_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *AlertingThreshold_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingThreshold) (interface{}, bool) {
	return nil, false
}

func (fpaiv *AlertingThreshold_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*AlertingThreshold))
}

// Contains returns a boolean indicating if value that is being held is present in given 'AlertingThreshold'
func (fpaiv *AlertingThreshold_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingThreshold) bool {
	slice := fpaiv.AlertingThreshold_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
}

// AlertingThreshold_FieldPathArrayOfValues allows storing slice of values for AlertingThreshold fields according to their type
type AlertingThreshold_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertingThreshold_FieldPath
}

func ParseAlertingThreshold_FieldPathArrayOfValues(pathStr, valuesStr string) (AlertingThreshold_FieldPathArrayOfValues, error) {
	fp, err := ParseAlertingThreshold_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 AlertingThreshold field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(AlertingThreshold_FieldPathArrayOfValues), nil
}

func MustParseAlertingThreshold_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingThreshold_FieldPathArrayOfValues {
	fpaov, err := ParseAlertingThreshold_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertingThreshold_FieldTerminalPathArrayOfValues struct {
	AlertingThreshold_FieldTerminalPath
	values interface{}
}

var _ AlertingThreshold_FieldPathArrayOfValues = (*AlertingThreshold_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertingThreshold_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertingThreshold_FieldPathSelectorValue:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	case AlertingThreshold_FieldPathSelectorIsInclusive:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertingThreshold_FieldTerminalPathArrayOfValues) AsValueArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}
func (fpaov *AlertingThreshold_FieldTerminalPathArrayOfValues) AsIsInclusiveArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}