alerting_policy_service.pb.fieldpath.go

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

package alerting_policy_client

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

	"github.com/iancoleman/strcase"
	"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"
	"google.golang.org/protobuf/types/known/fieldmaskpb"

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

// proto imports
import (
	alerting_policy "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alerting_policy"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/project"
	view "github.com/cloudwan/goten-sdk/runtime/api/view"
	watch_type "github.com/cloudwan/goten-sdk/runtime/api/watch_type"
	empty "github.com/golang/protobuf/ptypes/empty"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	field_mask "google.golang.org/genproto/protobuf/field_mask"
)

// 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
	_ = fieldmaskpb.FieldMask{}

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &alerting_policy.AlertingPolicy{}
	_ = &project.Project{}
	_ = &empty.Empty{}
	_ = &field_mask.FieldMask{}
	_ = &timestamp.Timestamp{}
	_ = view.View(0)
	_ = watch_type.WatchType(0)
)

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

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

type GetAlertingPolicyRequest_FieldPathSelector int32

const (
	GetAlertingPolicyRequest_FieldPathSelectorName      GetAlertingPolicyRequest_FieldPathSelector = 0
	GetAlertingPolicyRequest_FieldPathSelectorFieldMask GetAlertingPolicyRequest_FieldPathSelector = 1
	GetAlertingPolicyRequest_FieldPathSelectorView      GetAlertingPolicyRequest_FieldPathSelector = 2
)

func (s GetAlertingPolicyRequest_FieldPathSelector) String() string {
	switch s {
	case GetAlertingPolicyRequest_FieldPathSelectorName:
		return "name"
	case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case GetAlertingPolicyRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for GetAlertingPolicyRequest: %d", s))
	}
}

func BuildGetAlertingPolicyRequest_FieldPath(fp gotenobject.RawFieldPath) (GetAlertingPolicyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object GetAlertingPolicyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &GetAlertingPolicyRequest_FieldTerminalPath{selector: GetAlertingPolicyRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &GetAlertingPolicyRequest_FieldTerminalPath{selector: GetAlertingPolicyRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &GetAlertingPolicyRequest_FieldTerminalPath{selector: GetAlertingPolicyRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object GetAlertingPolicyRequest", fp)
}

func ParseGetAlertingPolicyRequest_FieldPath(rawField string) (GetAlertingPolicyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildGetAlertingPolicyRequest_FieldPath(fp)
}

func MustParseGetAlertingPolicyRequest_FieldPath(rawField string) GetAlertingPolicyRequest_FieldPath {
	fp, err := ParseGetAlertingPolicyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type GetAlertingPolicyRequest_FieldTerminalPath struct {
	selector GetAlertingPolicyRequest_FieldPathSelector
}

var _ GetAlertingPolicyRequest_FieldPath = (*GetAlertingPolicyRequest_FieldTerminalPath)(nil)

func (fp *GetAlertingPolicyRequest_FieldTerminalPath) Selector() GetAlertingPolicyRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source GetAlertingPolicyRequest
func (fp *GetAlertingPolicyRequest_FieldTerminalPath) Get(source *GetAlertingPolicyRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case GetAlertingPolicyRequest_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case GetAlertingPolicyRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for GetAlertingPolicyRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source GetAlertingPolicyRequest
func (fp *GetAlertingPolicyRequest_FieldTerminalPath) GetSingle(source *GetAlertingPolicyRequest) (interface{}, bool) {
	switch fp.selector {
	case GetAlertingPolicyRequest_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case GetAlertingPolicyRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for GetAlertingPolicyRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *GetAlertingPolicyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case GetAlertingPolicyRequest_FieldPathSelectorName:
		return (*alerting_policy.Reference)(nil)
	case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return (*alerting_policy.AlertingPolicy_FieldMask)(nil)
	case GetAlertingPolicyRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for GetAlertingPolicyRequest: %d", fp.selector))
	}
}

func (fp *GetAlertingPolicyRequest_FieldTerminalPath) ClearValue(item *GetAlertingPolicyRequest) {
	if item != nil {
		switch fp.selector {
		case GetAlertingPolicyRequest_FieldPathSelectorName:
			item.Name = nil
		case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case GetAlertingPolicyRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for GetAlertingPolicyRequest: %d", fp.selector))
		}
	}
}

func (fp *GetAlertingPolicyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*GetAlertingPolicyRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *GetAlertingPolicyRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == GetAlertingPolicyRequest_FieldPathSelectorName ||
		fp.selector == GetAlertingPolicyRequest_FieldPathSelectorFieldMask ||
		fp.selector == GetAlertingPolicyRequest_FieldPathSelectorView
}

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

func (fp *GetAlertingPolicyRequest_FieldTerminalPath) WithIValue(value interface{}) GetAlertingPolicyRequest_FieldPathValue {
	switch fp.selector {
	case GetAlertingPolicyRequest_FieldPathSelectorName:
		return &GetAlertingPolicyRequest_FieldTerminalPathValue{GetAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.Reference)}
	case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return &GetAlertingPolicyRequest_FieldTerminalPathValue{GetAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy_FieldMask)}
	case GetAlertingPolicyRequest_FieldPathSelectorView:
		return &GetAlertingPolicyRequest_FieldTerminalPathValue{GetAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetAlertingPolicyRequest: %d", fp.selector))
	}
}

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

func (fp *GetAlertingPolicyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) GetAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov := &GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues{GetAlertingPolicyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case GetAlertingPolicyRequest_FieldPathSelectorName:
		return &GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues{GetAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.Reference)}
	case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return &GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues{GetAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy_FieldMask)}
	case GetAlertingPolicyRequest_FieldPathSelectorView:
		return &GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues{GetAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetAlertingPolicyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseGetAlertingPolicyRequest_FieldPathValue(pathStr, valueStr string) GetAlertingPolicyRequest_FieldPathValue {
	fpv, err := ParseGetAlertingPolicyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type GetAlertingPolicyRequest_FieldTerminalPathValue struct {
	GetAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ GetAlertingPolicyRequest_FieldPathValue = (*GetAlertingPolicyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'GetAlertingPolicyRequest' as interface{}
func (fpv *GetAlertingPolicyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *GetAlertingPolicyRequest_FieldTerminalPathValue) AsNameValue() (*alerting_policy.Reference, bool) {
	res, ok := fpv.value.(*alerting_policy.Reference)
	return res, ok
}
func (fpv *GetAlertingPolicyRequest_FieldTerminalPathValue) AsFieldMaskValue() (*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpv *GetAlertingPolicyRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object GetAlertingPolicyRequest
func (fpv *GetAlertingPolicyRequest_FieldTerminalPathValue) SetTo(target **GetAlertingPolicyRequest) {
	if *target == nil {
		*target = new(GetAlertingPolicyRequest)
	}
	switch fpv.selector {
	case GetAlertingPolicyRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*alerting_policy.Reference)
	case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	case GetAlertingPolicyRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for GetAlertingPolicyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'GetAlertingPolicyRequest_FieldTerminalPathValue' with the value under path in 'GetAlertingPolicyRequest'.
func (fpv *GetAlertingPolicyRequest_FieldTerminalPathValue) CompareWith(source *GetAlertingPolicyRequest) (int, bool) {
	switch fpv.selector {
	case GetAlertingPolicyRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*alerting_policy.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return 0, false
	case GetAlertingPolicyRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for GetAlertingPolicyRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseGetAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr string) GetAlertingPolicyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseGetAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type GetAlertingPolicyRequest_FieldTerminalPathArrayItemValue struct {
	GetAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ GetAlertingPolicyRequest_FieldPathArrayItemValue = (*GetAlertingPolicyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *GetAlertingPolicyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *GetAlertingPolicyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetAlertingPolicyRequest_FieldPathArrayOfValues allows storing slice of values for GetAlertingPolicyRequest fields according to their type
type GetAlertingPolicyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	GetAlertingPolicyRequest_FieldPath
}

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

func MustParseGetAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) GetAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseGetAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues struct {
	GetAlertingPolicyRequest_FieldTerminalPath
	values interface{}
}

var _ GetAlertingPolicyRequest_FieldPathArrayOfValues = (*GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case GetAlertingPolicyRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*alerting_policy.Reference) {
			values = append(values, v)
		}
	case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask) {
			values = append(values, v)
		}
	case GetAlertingPolicyRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*alerting_policy.Reference, bool) {
	res, ok := fpaov.values.([]*alerting_policy.Reference)
	return res, ok
}
func (fpaov *GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpaov *GetAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

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

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

type BatchGetAlertingPoliciesRequest_FieldPathSelector int32

const (
	BatchGetAlertingPoliciesRequest_FieldPathSelectorNames     BatchGetAlertingPoliciesRequest_FieldPathSelector = 0
	BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask BatchGetAlertingPoliciesRequest_FieldPathSelector = 1
	BatchGetAlertingPoliciesRequest_FieldPathSelectorView      BatchGetAlertingPoliciesRequest_FieldPathSelector = 2
)

func (s BatchGetAlertingPoliciesRequest_FieldPathSelector) String() string {
	switch s {
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
		return "names"
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", s))
	}
}

func BuildBatchGetAlertingPoliciesRequest_FieldPath(fp gotenobject.RawFieldPath) (BatchGetAlertingPoliciesRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetAlertingPoliciesRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "names":
			return &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorNames}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetAlertingPoliciesRequest", fp)
}

func ParseBatchGetAlertingPoliciesRequest_FieldPath(rawField string) (BatchGetAlertingPoliciesRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetAlertingPoliciesRequest_FieldPath(fp)
}

func MustParseBatchGetAlertingPoliciesRequest_FieldPath(rawField string) BatchGetAlertingPoliciesRequest_FieldPath {
	fp, err := ParseBatchGetAlertingPoliciesRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetAlertingPoliciesRequest_FieldTerminalPath struct {
	selector BatchGetAlertingPoliciesRequest_FieldPathSelector
}

var _ BatchGetAlertingPoliciesRequest_FieldPath = (*BatchGetAlertingPoliciesRequest_FieldTerminalPath)(nil)

func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) Selector() BatchGetAlertingPoliciesRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source BatchGetAlertingPoliciesRequest
func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) Get(source *BatchGetAlertingPoliciesRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
			for _, value := range source.GetNames() {
				values = append(values, value)
			}
		case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source BatchGetAlertingPoliciesRequest
func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) GetSingle(source *BatchGetAlertingPoliciesRequest) (interface{}, bool) {
	switch fp.selector {
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
		res := source.GetNames()
		return res, res != nil
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
		return ([]*alerting_policy.Reference)(nil)
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return (*alerting_policy.AlertingPolicy_FieldMask)(nil)
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", fp.selector))
	}
}

func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) ClearValue(item *BatchGetAlertingPoliciesRequest) {
	if item != nil {
		switch fp.selector {
		case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
			item.Names = nil
		case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", fp.selector))
		}
	}
}

func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetAlertingPoliciesRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == BatchGetAlertingPoliciesRequest_FieldPathSelectorNames ||
		fp.selector == BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask ||
		fp.selector == BatchGetAlertingPoliciesRequest_FieldPathSelectorView
}

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

func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) WithIValue(value interface{}) BatchGetAlertingPoliciesRequest_FieldPathValue {
	switch fp.selector {
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
		return &BatchGetAlertingPoliciesRequest_FieldTerminalPathValue{BatchGetAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.([]*alerting_policy.Reference)}
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return &BatchGetAlertingPoliciesRequest_FieldTerminalPathValue{BatchGetAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy_FieldMask)}
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
		return &BatchGetAlertingPoliciesRequest_FieldTerminalPathValue{BatchGetAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", fp.selector))
	}
}

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

func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetAlertingPoliciesRequest_FieldPathArrayOfValues {
	fpaov := &BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{BatchGetAlertingPoliciesRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
		return &BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{BatchGetAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([][]*alerting_policy.Reference)}
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return &BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{BatchGetAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy_FieldMask)}
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
		return &BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{BatchGetAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetAlertingPoliciesRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetAlertingPoliciesRequest_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
		return &BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayItemValue{BatchGetAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", fp.selector))
	}
}

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

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

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

func MustParseBatchGetAlertingPoliciesRequest_FieldPathValue(pathStr, valueStr string) BatchGetAlertingPoliciesRequest_FieldPathValue {
	fpv, err := ParseBatchGetAlertingPoliciesRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetAlertingPoliciesRequest_FieldTerminalPathValue struct {
	BatchGetAlertingPoliciesRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetAlertingPoliciesRequest_FieldPathValue = (*BatchGetAlertingPoliciesRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetAlertingPoliciesRequest' as interface{}
func (fpv *BatchGetAlertingPoliciesRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetAlertingPoliciesRequest_FieldTerminalPathValue) AsNamesValue() ([]*alerting_policy.Reference, bool) {
	res, ok := fpv.value.([]*alerting_policy.Reference)
	return res, ok
}
func (fpv *BatchGetAlertingPoliciesRequest_FieldTerminalPathValue) AsFieldMaskValue() (*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpv *BatchGetAlertingPoliciesRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetAlertingPoliciesRequest
func (fpv *BatchGetAlertingPoliciesRequest_FieldTerminalPathValue) SetTo(target **BatchGetAlertingPoliciesRequest) {
	if *target == nil {
		*target = new(BatchGetAlertingPoliciesRequest)
	}
	switch fpv.selector {
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
		(*target).Names = fpv.value.([]*alerting_policy.Reference)
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'BatchGetAlertingPoliciesRequest_FieldTerminalPathValue' with the value under path in 'BatchGetAlertingPoliciesRequest'.
func (fpv *BatchGetAlertingPoliciesRequest_FieldTerminalPathValue) CompareWith(source *BatchGetAlertingPoliciesRequest) (int, bool) {
	switch fpv.selector {
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
		return 0, false
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return 0, false
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseBatchGetAlertingPoliciesRequest_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetAlertingPoliciesRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetAlertingPoliciesRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayItemValue struct {
	BatchGetAlertingPoliciesRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetAlertingPoliciesRequest_FieldPathArrayItemValue = (*BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetAlertingPoliciesRequest as interface{}
func (fpaiv *BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayItemValue) AsNamesItemValue() (*alerting_policy.Reference, bool) {
	res, ok := fpaiv.value.(*alerting_policy.Reference)
	return res, ok
}

func (fpaiv *BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetAlertingPoliciesRequest) (interface{}, bool) {
	return nil, false
}

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

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

// BatchGetAlertingPoliciesRequest_FieldPathArrayOfValues allows storing slice of values for BatchGetAlertingPoliciesRequest fields according to their type
type BatchGetAlertingPoliciesRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetAlertingPoliciesRequest_FieldPath
}

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

func MustParseBatchGetAlertingPoliciesRequest_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetAlertingPoliciesRequest_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetAlertingPoliciesRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues struct {
	BatchGetAlertingPoliciesRequest_FieldTerminalPath
	values interface{}
}

var _ BatchGetAlertingPoliciesRequest_FieldPathArrayOfValues = (*BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
		for _, v := range fpaov.values.([][]*alerting_policy.Reference) {
			values = append(values, v)
		}
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask) {
			values = append(values, v)
		}
	case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsNamesArrayOfValues() ([][]*alerting_policy.Reference, bool) {
	res, ok := fpaov.values.([][]*alerting_policy.Reference)
	return res, ok
}
func (fpaov *BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpaov *BatchGetAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

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

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

type BatchGetAlertingPoliciesResponse_FieldPathSelector int32

const (
	BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies BatchGetAlertingPoliciesResponse_FieldPathSelector = 0
	BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing          BatchGetAlertingPoliciesResponse_FieldPathSelector = 1
)

func (s BatchGetAlertingPoliciesResponse_FieldPathSelector) String() string {
	switch s {
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return "alerting_policies"
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
		return "missing"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesResponse: %d", s))
	}
}

func BuildBatchGetAlertingPoliciesResponse_FieldPath(fp gotenobject.RawFieldPath) (BatchGetAlertingPoliciesResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetAlertingPoliciesResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "alerting_policies", "alertingPolicies", "alerting-policies":
			return &BatchGetAlertingPoliciesResponse_FieldTerminalPath{selector: BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies}, nil
		case "missing":
			return &BatchGetAlertingPoliciesResponse_FieldTerminalPath{selector: BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing}, nil
		}
	} else {
		switch fp[0] {
		case "alerting_policies", "alertingPolicies", "alerting-policies":
			if subpath, err := alerting_policy.BuildAlertingPolicy_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &BatchGetAlertingPoliciesResponse_FieldSubPath{selector: BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetAlertingPoliciesResponse", fp)
}

func ParseBatchGetAlertingPoliciesResponse_FieldPath(rawField string) (BatchGetAlertingPoliciesResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetAlertingPoliciesResponse_FieldPath(fp)
}

func MustParseBatchGetAlertingPoliciesResponse_FieldPath(rawField string) BatchGetAlertingPoliciesResponse_FieldPath {
	fp, err := ParseBatchGetAlertingPoliciesResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetAlertingPoliciesResponse_FieldTerminalPath struct {
	selector BatchGetAlertingPoliciesResponse_FieldPathSelector
}

var _ BatchGetAlertingPoliciesResponse_FieldPath = (*BatchGetAlertingPoliciesResponse_FieldTerminalPath)(nil)

func (fp *BatchGetAlertingPoliciesResponse_FieldTerminalPath) Selector() BatchGetAlertingPoliciesResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source BatchGetAlertingPoliciesResponse
func (fp *BatchGetAlertingPoliciesResponse_FieldTerminalPath) Get(source *BatchGetAlertingPoliciesResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
			for _, value := range source.GetAlertingPolicies() {
				values = append(values, value)
			}
		case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
			for _, value := range source.GetMissing() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesResponse: %d", fp.selector))
		}
	}
	return
}

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

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

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

// GetDefault returns a default value of the field type
func (fp *BatchGetAlertingPoliciesResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return ([]*alerting_policy.AlertingPolicy)(nil)
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
		return ([]*alerting_policy.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesResponse: %d", fp.selector))
	}
}

func (fp *BatchGetAlertingPoliciesResponse_FieldTerminalPath) ClearValue(item *BatchGetAlertingPoliciesResponse) {
	if item != nil {
		switch fp.selector {
		case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
			item.AlertingPolicies = nil
		case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
			item.Missing = nil
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesResponse: %d", fp.selector))
		}
	}
}

func (fp *BatchGetAlertingPoliciesResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetAlertingPoliciesResponse))
}

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

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

func (fp *BatchGetAlertingPoliciesResponse_FieldTerminalPath) WithIValue(value interface{}) BatchGetAlertingPoliciesResponse_FieldPathValue {
	switch fp.selector {
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return &BatchGetAlertingPoliciesResponse_FieldTerminalPathValue{BatchGetAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.([]*alerting_policy.AlertingPolicy)}
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
		return &BatchGetAlertingPoliciesResponse_FieldTerminalPathValue{BatchGetAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.([]*alerting_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesResponse: %d", fp.selector))
	}
}

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

func (fp *BatchGetAlertingPoliciesResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetAlertingPoliciesResponse_FieldPathArrayOfValues {
	fpaov := &BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{BatchGetAlertingPoliciesResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return &BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{BatchGetAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([][]*alerting_policy.AlertingPolicy)}
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
		return &BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{BatchGetAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([][]*alerting_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetAlertingPoliciesResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetAlertingPoliciesResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return &BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayItemValue{BatchGetAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy)}
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
		return &BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayItemValue{BatchGetAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(*alerting_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesResponse: %d", fp.selector))
	}
}

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

type BatchGetAlertingPoliciesResponse_FieldSubPath struct {
	selector BatchGetAlertingPoliciesResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ BatchGetAlertingPoliciesResponse_FieldPath = (*BatchGetAlertingPoliciesResponse_FieldSubPath)(nil)

func (fps *BatchGetAlertingPoliciesResponse_FieldSubPath) Selector() BatchGetAlertingPoliciesResponse_FieldPathSelector {
	return fps.selector
}
func (fps *BatchGetAlertingPoliciesResponse_FieldSubPath) AsAlertingPoliciesSubPath() (alerting_policy.AlertingPolicy_FieldPath, bool) {
	res, ok := fps.subPath.(alerting_policy.AlertingPolicy_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source BatchGetAlertingPoliciesResponse
func (fps *BatchGetAlertingPoliciesResponse_FieldSubPath) Get(source *BatchGetAlertingPoliciesResponse) (values []interface{}) {
	if asAlertingPolicyFieldPath, ok := fps.AsAlertingPoliciesSubPath(); ok {
		for _, item := range source.GetAlertingPolicies() {
			values = append(values, asAlertingPolicyFieldPath.Get(item)...)
		}
	} else {
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesResponse: %d", fps.selector))
	}
	return
}

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

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

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

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

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

func (fps *BatchGetAlertingPoliciesResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*BatchGetAlertingPoliciesResponse))
}

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

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

func (fps *BatchGetAlertingPoliciesResponse_FieldSubPath) WithIValue(value interface{}) BatchGetAlertingPoliciesResponse_FieldPathValue {
	return &BatchGetAlertingPoliciesResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *BatchGetAlertingPoliciesResponse_FieldSubPath) WithIArrayOfValues(values interface{}) BatchGetAlertingPoliciesResponse_FieldPathArrayOfValues {
	return &BatchGetAlertingPoliciesResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *BatchGetAlertingPoliciesResponse_FieldSubPath) WithIArrayItemValue(value interface{}) BatchGetAlertingPoliciesResponse_FieldPathArrayItemValue {
	return &BatchGetAlertingPoliciesResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseBatchGetAlertingPoliciesResponse_FieldPathValue(pathStr, valueStr string) BatchGetAlertingPoliciesResponse_FieldPathValue {
	fpv, err := ParseBatchGetAlertingPoliciesResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetAlertingPoliciesResponse_FieldTerminalPathValue struct {
	BatchGetAlertingPoliciesResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetAlertingPoliciesResponse_FieldPathValue = (*BatchGetAlertingPoliciesResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetAlertingPoliciesResponse' as interface{}
func (fpv *BatchGetAlertingPoliciesResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetAlertingPoliciesResponse_FieldTerminalPathValue) AsAlertingPoliciesValue() ([]*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpv.value.([]*alerting_policy.AlertingPolicy)
	return res, ok
}
func (fpv *BatchGetAlertingPoliciesResponse_FieldTerminalPathValue) AsMissingValue() ([]*alerting_policy.Reference, bool) {
	res, ok := fpv.value.([]*alerting_policy.Reference)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetAlertingPoliciesResponse
func (fpv *BatchGetAlertingPoliciesResponse_FieldTerminalPathValue) SetTo(target **BatchGetAlertingPoliciesResponse) {
	if *target == nil {
		*target = new(BatchGetAlertingPoliciesResponse)
	}
	switch fpv.selector {
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		(*target).AlertingPolicies = fpv.value.([]*alerting_policy.AlertingPolicy)
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
		(*target).Missing = fpv.value.([]*alerting_policy.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetAlertingPoliciesResponse: %d", fpv.selector))
	}
}

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

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

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

type BatchGetAlertingPoliciesResponse_FieldSubPathValue struct {
	BatchGetAlertingPoliciesResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ BatchGetAlertingPoliciesResponse_FieldPathValue = (*BatchGetAlertingPoliciesResponse_FieldSubPathValue)(nil)

func (fpvs *BatchGetAlertingPoliciesResponse_FieldSubPathValue) AsAlertingPoliciesPathValue() (alerting_policy.AlertingPolicy_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseBatchGetAlertingPoliciesResponse_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetAlertingPoliciesResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetAlertingPoliciesResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayItemValue struct {
	BatchGetAlertingPoliciesResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetAlertingPoliciesResponse_FieldPathArrayItemValue = (*BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetAlertingPoliciesResponse as interface{}
func (fpaiv *BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) AsAlertingPoliciesItemValue() (*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpaiv.value.(*alerting_policy.AlertingPolicy)
	return res, ok
}
func (fpaiv *BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) AsMissingItemValue() (*alerting_policy.Reference, bool) {
	res, ok := fpaiv.value.(*alerting_policy.Reference)
	return res, ok
}

func (fpaiv *BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetAlertingPoliciesResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *BatchGetAlertingPoliciesResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *BatchGetAlertingPoliciesResponse_FieldSubPathArrayItemValue) AsAlertingPoliciesPathItemValue() (alerting_policy.AlertingPolicy_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(alerting_policy.AlertingPolicy_FieldPathArrayItemValue)
	return res, ok
}

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

// BatchGetAlertingPoliciesResponse_FieldPathArrayOfValues allows storing slice of values for BatchGetAlertingPoliciesResponse fields according to their type
type BatchGetAlertingPoliciesResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetAlertingPoliciesResponse_FieldPath
}

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

func MustParseBatchGetAlertingPoliciesResponse_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetAlertingPoliciesResponse_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetAlertingPoliciesResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayOfValues struct {
	BatchGetAlertingPoliciesResponse_FieldTerminalPath
	values interface{}
}

var _ BatchGetAlertingPoliciesResponse_FieldPathArrayOfValues = (*BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		for _, v := range fpaov.values.([][]*alerting_policy.AlertingPolicy) {
			values = append(values, v)
		}
	case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
		for _, v := range fpaov.values.([][]*alerting_policy.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsAlertingPoliciesArrayOfValues() ([][]*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpaov.values.([][]*alerting_policy.AlertingPolicy)
	return res, ok
}
func (fpaov *BatchGetAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsMissingArrayOfValues() ([][]*alerting_policy.Reference, bool) {
	res, ok := fpaov.values.([][]*alerting_policy.Reference)
	return res, ok
}

type BatchGetAlertingPoliciesResponse_FieldSubPathArrayOfValues struct {
	BatchGetAlertingPoliciesResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ BatchGetAlertingPoliciesResponse_FieldPathArrayOfValues = (*BatchGetAlertingPoliciesResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *BatchGetAlertingPoliciesResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *BatchGetAlertingPoliciesResponse_FieldSubPathArrayOfValues) AsAlertingPoliciesPathArrayOfValues() (alerting_policy.AlertingPolicy_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(alerting_policy.AlertingPolicy_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ListAlertingPoliciesRequest_FieldPathSelector int32

const (
	ListAlertingPoliciesRequest_FieldPathSelectorParent    ListAlertingPoliciesRequest_FieldPathSelector = 0
	ListAlertingPoliciesRequest_FieldPathSelectorPageSize  ListAlertingPoliciesRequest_FieldPathSelector = 1
	ListAlertingPoliciesRequest_FieldPathSelectorPageToken ListAlertingPoliciesRequest_FieldPathSelector = 2
	ListAlertingPoliciesRequest_FieldPathSelectorOrderBy   ListAlertingPoliciesRequest_FieldPathSelector = 3
	ListAlertingPoliciesRequest_FieldPathSelectorFilter    ListAlertingPoliciesRequest_FieldPathSelector = 4
	ListAlertingPoliciesRequest_FieldPathSelectorFieldMask ListAlertingPoliciesRequest_FieldPathSelector = 5
	ListAlertingPoliciesRequest_FieldPathSelectorView      ListAlertingPoliciesRequest_FieldPathSelector = 6
)

func (s ListAlertingPoliciesRequest_FieldPathSelector) String() string {
	switch s {
	case ListAlertingPoliciesRequest_FieldPathSelectorParent:
		return "parent"
	case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return "page_size"
	case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return "page_token"
	case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
		return "filter"
	case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case ListAlertingPoliciesRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesRequest: %d", s))
	}
}

func BuildListAlertingPoliciesRequest_FieldPath(fp gotenobject.RawFieldPath) (ListAlertingPoliciesRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListAlertingPoliciesRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorOrderBy}, nil
		case "filter":
			return &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListAlertingPoliciesRequest", fp)
}

func ParseListAlertingPoliciesRequest_FieldPath(rawField string) (ListAlertingPoliciesRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListAlertingPoliciesRequest_FieldPath(fp)
}

func MustParseListAlertingPoliciesRequest_FieldPath(rawField string) ListAlertingPoliciesRequest_FieldPath {
	fp, err := ParseListAlertingPoliciesRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListAlertingPoliciesRequest_FieldTerminalPath struct {
	selector ListAlertingPoliciesRequest_FieldPathSelector
}

var _ ListAlertingPoliciesRequest_FieldPath = (*ListAlertingPoliciesRequest_FieldTerminalPath)(nil)

func (fp *ListAlertingPoliciesRequest_FieldTerminalPath) Selector() ListAlertingPoliciesRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListAlertingPoliciesRequest
func (fp *ListAlertingPoliciesRequest_FieldTerminalPath) Get(source *ListAlertingPoliciesRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListAlertingPoliciesRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case ListAlertingPoliciesRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListAlertingPoliciesRequest
func (fp *ListAlertingPoliciesRequest_FieldTerminalPath) GetSingle(source *ListAlertingPoliciesRequest) (interface{}, bool) {
	switch fp.selector {
	case ListAlertingPoliciesRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case ListAlertingPoliciesRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListAlertingPoliciesRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListAlertingPoliciesRequest_FieldPathSelectorParent:
		return (*alerting_policy.ParentName)(nil)
	case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return int32(0)
	case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return (*alerting_policy.PagerCursor)(nil)
	case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return (*alerting_policy.OrderBy)(nil)
	case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
		return (*alerting_policy.Filter)(nil)
	case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return (*alerting_policy.AlertingPolicy_FieldMask)(nil)
	case ListAlertingPoliciesRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesRequest: %d", fp.selector))
	}
}

func (fp *ListAlertingPoliciesRequest_FieldTerminalPath) ClearValue(item *ListAlertingPoliciesRequest) {
	if item != nil {
		switch fp.selector {
		case ListAlertingPoliciesRequest_FieldPathSelectorParent:
			item.Parent = nil
		case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case ListAlertingPoliciesRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesRequest: %d", fp.selector))
		}
	}
}

func (fp *ListAlertingPoliciesRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListAlertingPoliciesRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListAlertingPoliciesRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListAlertingPoliciesRequest_FieldPathSelectorParent ||
		fp.selector == ListAlertingPoliciesRequest_FieldPathSelectorPageSize ||
		fp.selector == ListAlertingPoliciesRequest_FieldPathSelectorPageToken ||
		fp.selector == ListAlertingPoliciesRequest_FieldPathSelectorOrderBy ||
		fp.selector == ListAlertingPoliciesRequest_FieldPathSelectorFilter ||
		fp.selector == ListAlertingPoliciesRequest_FieldPathSelectorFieldMask ||
		fp.selector == ListAlertingPoliciesRequest_FieldPathSelectorView
}

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

func (fp *ListAlertingPoliciesRequest_FieldTerminalPath) WithIValue(value interface{}) ListAlertingPoliciesRequest_FieldPathValue {
	switch fp.selector {
	case ListAlertingPoliciesRequest_FieldPathSelectorParent:
		return &ListAlertingPoliciesRequest_FieldTerminalPathValue{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.ParentName)}
	case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return &ListAlertingPoliciesRequest_FieldTerminalPathValue{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return &ListAlertingPoliciesRequest_FieldTerminalPathValue{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.PagerCursor)}
	case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return &ListAlertingPoliciesRequest_FieldTerminalPathValue{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.OrderBy)}
	case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
		return &ListAlertingPoliciesRequest_FieldTerminalPathValue{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.Filter)}
	case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return &ListAlertingPoliciesRequest_FieldTerminalPathValue{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy_FieldMask)}
	case ListAlertingPoliciesRequest_FieldPathSelectorView:
		return &ListAlertingPoliciesRequest_FieldTerminalPathValue{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesRequest: %d", fp.selector))
	}
}

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

func (fp *ListAlertingPoliciesRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListAlertingPoliciesRequest_FieldPathArrayOfValues {
	fpaov := &ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{ListAlertingPoliciesRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListAlertingPoliciesRequest_FieldPathSelectorParent:
		return &ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.ParentName)}
	case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return &ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return &ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.PagerCursor)}
	case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return &ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.OrderBy)}
	case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
		return &ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.Filter)}
	case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return &ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy_FieldMask)}
	case ListAlertingPoliciesRequest_FieldPathSelectorView:
		return &ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{ListAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseListAlertingPoliciesRequest_FieldPathValue(pathStr, valueStr string) ListAlertingPoliciesRequest_FieldPathValue {
	fpv, err := ParseListAlertingPoliciesRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListAlertingPoliciesRequest_FieldTerminalPathValue struct {
	ListAlertingPoliciesRequest_FieldTerminalPath
	value interface{}
}

var _ ListAlertingPoliciesRequest_FieldPathValue = (*ListAlertingPoliciesRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListAlertingPoliciesRequest' as interface{}
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) AsParentValue() (*alerting_policy.ParentName, bool) {
	res, ok := fpv.value.(*alerting_policy.ParentName)
	return res, ok
}
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) AsPageSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) AsPageTokenValue() (*alerting_policy.PagerCursor, bool) {
	res, ok := fpv.value.(*alerting_policy.PagerCursor)
	return res, ok
}
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) AsOrderByValue() (*alerting_policy.OrderBy, bool) {
	res, ok := fpv.value.(*alerting_policy.OrderBy)
	return res, ok
}
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) AsFilterValue() (*alerting_policy.Filter, bool) {
	res, ok := fpv.value.(*alerting_policy.Filter)
	return res, ok
}
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) AsFieldMaskValue() (*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object ListAlertingPoliciesRequest
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) SetTo(target **ListAlertingPoliciesRequest) {
	if *target == nil {
		*target = new(ListAlertingPoliciesRequest)
	}
	switch fpv.selector {
	case ListAlertingPoliciesRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*alerting_policy.ParentName)
	case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*alerting_policy.PagerCursor)
	case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*alerting_policy.OrderBy)
	case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*alerting_policy.Filter)
	case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	case ListAlertingPoliciesRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListAlertingPoliciesRequest_FieldTerminalPathValue' with the value under path in 'ListAlertingPoliciesRequest'.
func (fpv *ListAlertingPoliciesRequest_FieldTerminalPathValue) CompareWith(source *ListAlertingPoliciesRequest) (int, bool) {
	switch fpv.selector {
	case ListAlertingPoliciesRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*alerting_policy.ParentName)
		rightValue := source.GetParent()
		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 ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetPageSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return 0, false
	case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return 0, false
	case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
		return 0, false
	case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return 0, false
	case ListAlertingPoliciesRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseListAlertingPoliciesRequest_FieldPathArrayItemValue(pathStr, valueStr string) ListAlertingPoliciesRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseListAlertingPoliciesRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListAlertingPoliciesRequest_FieldTerminalPathArrayItemValue struct {
	ListAlertingPoliciesRequest_FieldTerminalPath
	value interface{}
}

var _ ListAlertingPoliciesRequest_FieldPathArrayItemValue = (*ListAlertingPoliciesRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ListAlertingPoliciesRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ListAlertingPoliciesRequest) (interface{}, bool) {
	return nil, false
}

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

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

// ListAlertingPoliciesRequest_FieldPathArrayOfValues allows storing slice of values for ListAlertingPoliciesRequest fields according to their type
type ListAlertingPoliciesRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListAlertingPoliciesRequest_FieldPath
}

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

func MustParseListAlertingPoliciesRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ListAlertingPoliciesRequest_FieldPathArrayOfValues {
	fpaov, err := ParseListAlertingPoliciesRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues struct {
	ListAlertingPoliciesRequest_FieldTerminalPath
	values interface{}
}

var _ ListAlertingPoliciesRequest_FieldPathArrayOfValues = (*ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListAlertingPoliciesRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*alerting_policy.ParentName) {
			values = append(values, v)
		}
	case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*alerting_policy.PagerCursor) {
			values = append(values, v)
		}
	case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*alerting_policy.OrderBy) {
			values = append(values, v)
		}
	case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*alerting_policy.Filter) {
			values = append(values, v)
		}
	case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask) {
			values = append(values, v)
		}
	case ListAlertingPoliciesRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*alerting_policy.ParentName, bool) {
	res, ok := fpaov.values.([]*alerting_policy.ParentName)
	return res, ok
}
func (fpaov *ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*alerting_policy.PagerCursor, bool) {
	res, ok := fpaov.values.([]*alerting_policy.PagerCursor)
	return res, ok
}
func (fpaov *ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*alerting_policy.OrderBy, bool) {
	res, ok := fpaov.values.([]*alerting_policy.OrderBy)
	return res, ok
}
func (fpaov *ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*alerting_policy.Filter, bool) {
	res, ok := fpaov.values.([]*alerting_policy.Filter)
	return res, ok
}
func (fpaov *ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpaov *ListAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

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

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

type ListAlertingPoliciesResponse_FieldPathSelector int32

const (
	ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies ListAlertingPoliciesResponse_FieldPathSelector = 0
	ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken    ListAlertingPoliciesResponse_FieldPathSelector = 1
	ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken    ListAlertingPoliciesResponse_FieldPathSelector = 2
)

func (s ListAlertingPoliciesResponse_FieldPathSelector) String() string {
	switch s {
	case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return "alerting_policies"
	case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
		return "next_page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", s))
	}
}

func BuildListAlertingPoliciesResponse_FieldPath(fp gotenobject.RawFieldPath) (ListAlertingPoliciesResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListAlertingPoliciesResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "alerting_policies", "alertingPolicies", "alerting-policies":
			return &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies}, nil
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken}, nil
		}
	} else {
		switch fp[0] {
		case "alerting_policies", "alertingPolicies", "alerting-policies":
			if subpath, err := alerting_policy.BuildAlertingPolicy_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListAlertingPoliciesResponse_FieldSubPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListAlertingPoliciesResponse", fp)
}

func ParseListAlertingPoliciesResponse_FieldPath(rawField string) (ListAlertingPoliciesResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListAlertingPoliciesResponse_FieldPath(fp)
}

func MustParseListAlertingPoliciesResponse_FieldPath(rawField string) ListAlertingPoliciesResponse_FieldPath {
	fp, err := ParseListAlertingPoliciesResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListAlertingPoliciesResponse_FieldTerminalPath struct {
	selector ListAlertingPoliciesResponse_FieldPathSelector
}

var _ ListAlertingPoliciesResponse_FieldPath = (*ListAlertingPoliciesResponse_FieldTerminalPath)(nil)

func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) Selector() ListAlertingPoliciesResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListAlertingPoliciesResponse
func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) Get(source *ListAlertingPoliciesResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
			for _, value := range source.GetAlertingPolicies() {
				values = append(values, value)
			}
		case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
			if source.PrevPageToken != nil {
				values = append(values, source.PrevPageToken)
			}
		case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
			if source.NextPageToken != nil {
				values = append(values, source.NextPageToken)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListAlertingPoliciesResponse
func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) GetSingle(source *ListAlertingPoliciesResponse) (interface{}, bool) {
	switch fp.selector {
	case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		res := source.GetAlertingPolicies()
		return res, res != nil
	case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
		res := source.GetPrevPageToken()
		return res, res != nil
	case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
		res := source.GetNextPageToken()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return ([]*alerting_policy.AlertingPolicy)(nil)
	case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
		return (*alerting_policy.PagerCursor)(nil)
	case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
		return (*alerting_policy.PagerCursor)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", fp.selector))
	}
}

func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) ClearValue(item *ListAlertingPoliciesResponse) {
	if item != nil {
		switch fp.selector {
		case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
			item.AlertingPolicies = nil
		case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", fp.selector))
		}
	}
}

func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListAlertingPoliciesResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken ||
		fp.selector == ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken
}

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

func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) WithIValue(value interface{}) ListAlertingPoliciesResponse_FieldPathValue {
	switch fp.selector {
	case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return &ListAlertingPoliciesResponse_FieldTerminalPathValue{ListAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.([]*alerting_policy.AlertingPolicy)}
	case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
		return &ListAlertingPoliciesResponse_FieldTerminalPathValue{ListAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(*alerting_policy.PagerCursor)}
	case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
		return &ListAlertingPoliciesResponse_FieldTerminalPathValue{ListAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(*alerting_policy.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", fp.selector))
	}
}

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

func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListAlertingPoliciesResponse_FieldPathArrayOfValues {
	fpaov := &ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{ListAlertingPoliciesResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return &ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{ListAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([][]*alerting_policy.AlertingPolicy)}
	case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
		return &ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{ListAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([]*alerting_policy.PagerCursor)}
	case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
		return &ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{ListAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([]*alerting_policy.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *ListAlertingPoliciesResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListAlertingPoliciesResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		return &ListAlertingPoliciesResponse_FieldTerminalPathArrayItemValue{ListAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", fp.selector))
	}
}

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

type ListAlertingPoliciesResponse_FieldSubPath struct {
	selector ListAlertingPoliciesResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListAlertingPoliciesResponse_FieldPath = (*ListAlertingPoliciesResponse_FieldSubPath)(nil)

func (fps *ListAlertingPoliciesResponse_FieldSubPath) Selector() ListAlertingPoliciesResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ListAlertingPoliciesResponse_FieldSubPath) AsAlertingPoliciesSubPath() (alerting_policy.AlertingPolicy_FieldPath, bool) {
	res, ok := fps.subPath.(alerting_policy.AlertingPolicy_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source ListAlertingPoliciesResponse
func (fps *ListAlertingPoliciesResponse_FieldSubPath) Get(source *ListAlertingPoliciesResponse) (values []interface{}) {
	if asAlertingPolicyFieldPath, ok := fps.AsAlertingPoliciesSubPath(); ok {
		for _, item := range source.GetAlertingPolicies() {
			values = append(values, asAlertingPolicyFieldPath.Get(item)...)
		}
	} else {
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", fps.selector))
	}
	return
}

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

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

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

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

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

func (fps *ListAlertingPoliciesResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListAlertingPoliciesResponse))
}

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

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

func (fps *ListAlertingPoliciesResponse_FieldSubPath) WithIValue(value interface{}) ListAlertingPoliciesResponse_FieldPathValue {
	return &ListAlertingPoliciesResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ListAlertingPoliciesResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ListAlertingPoliciesResponse_FieldPathArrayOfValues {
	return &ListAlertingPoliciesResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ListAlertingPoliciesResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ListAlertingPoliciesResponse_FieldPathArrayItemValue {
	return &ListAlertingPoliciesResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseListAlertingPoliciesResponse_FieldPathValue(pathStr, valueStr string) ListAlertingPoliciesResponse_FieldPathValue {
	fpv, err := ParseListAlertingPoliciesResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListAlertingPoliciesResponse_FieldTerminalPathValue struct {
	ListAlertingPoliciesResponse_FieldTerminalPath
	value interface{}
}

var _ ListAlertingPoliciesResponse_FieldPathValue = (*ListAlertingPoliciesResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListAlertingPoliciesResponse' as interface{}
func (fpv *ListAlertingPoliciesResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListAlertingPoliciesResponse_FieldTerminalPathValue) AsAlertingPoliciesValue() ([]*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpv.value.([]*alerting_policy.AlertingPolicy)
	return res, ok
}
func (fpv *ListAlertingPoliciesResponse_FieldTerminalPathValue) AsPrevPageTokenValue() (*alerting_policy.PagerCursor, bool) {
	res, ok := fpv.value.(*alerting_policy.PagerCursor)
	return res, ok
}
func (fpv *ListAlertingPoliciesResponse_FieldTerminalPathValue) AsNextPageTokenValue() (*alerting_policy.PagerCursor, bool) {
	res, ok := fpv.value.(*alerting_policy.PagerCursor)
	return res, ok
}

// SetTo stores value for selected field for object ListAlertingPoliciesResponse
func (fpv *ListAlertingPoliciesResponse_FieldTerminalPathValue) SetTo(target **ListAlertingPoliciesResponse) {
	if *target == nil {
		*target = new(ListAlertingPoliciesResponse)
	}
	switch fpv.selector {
	case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		(*target).AlertingPolicies = fpv.value.([]*alerting_policy.AlertingPolicy)
	case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*alerting_policy.PagerCursor)
	case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*alerting_policy.PagerCursor)
	default:
		panic(fmt.Sprintf("Invalid selector for ListAlertingPoliciesResponse: %d", fpv.selector))
	}
}

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

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

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

type ListAlertingPoliciesResponse_FieldSubPathValue struct {
	ListAlertingPoliciesResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListAlertingPoliciesResponse_FieldPathValue = (*ListAlertingPoliciesResponse_FieldSubPathValue)(nil)

func (fpvs *ListAlertingPoliciesResponse_FieldSubPathValue) AsAlertingPoliciesPathValue() (alerting_policy.AlertingPolicy_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseListAlertingPoliciesResponse_FieldPathArrayItemValue(pathStr, valueStr string) ListAlertingPoliciesResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseListAlertingPoliciesResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListAlertingPoliciesResponse_FieldTerminalPathArrayItemValue struct {
	ListAlertingPoliciesResponse_FieldTerminalPath
	value interface{}
}

var _ ListAlertingPoliciesResponse_FieldPathArrayItemValue = (*ListAlertingPoliciesResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListAlertingPoliciesResponse as interface{}
func (fpaiv *ListAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ListAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) AsAlertingPoliciesItemValue() (*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpaiv.value.(*alerting_policy.AlertingPolicy)
	return res, ok
}

func (fpaiv *ListAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ListAlertingPoliciesResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ListAlertingPoliciesResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListAlertingPoliciesResponse_FieldSubPathArrayItemValue) AsAlertingPoliciesPathItemValue() (alerting_policy.AlertingPolicy_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(alerting_policy.AlertingPolicy_FieldPathArrayItemValue)
	return res, ok
}

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

// ListAlertingPoliciesResponse_FieldPathArrayOfValues allows storing slice of values for ListAlertingPoliciesResponse fields according to their type
type ListAlertingPoliciesResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListAlertingPoliciesResponse_FieldPath
}

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

func MustParseListAlertingPoliciesResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ListAlertingPoliciesResponse_FieldPathArrayOfValues {
	fpaov, err := ParseListAlertingPoliciesResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues struct {
	ListAlertingPoliciesResponse_FieldTerminalPath
	values interface{}
}

var _ ListAlertingPoliciesResponse_FieldPathArrayOfValues = (*ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
		for _, v := range fpaov.values.([][]*alerting_policy.AlertingPolicy) {
			values = append(values, v)
		}
	case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*alerting_policy.PagerCursor) {
			values = append(values, v)
		}
	case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*alerting_policy.PagerCursor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsAlertingPoliciesArrayOfValues() ([][]*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpaov.values.([][]*alerting_policy.AlertingPolicy)
	return res, ok
}
func (fpaov *ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*alerting_policy.PagerCursor, bool) {
	res, ok := fpaov.values.([]*alerting_policy.PagerCursor)
	return res, ok
}
func (fpaov *ListAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*alerting_policy.PagerCursor, bool) {
	res, ok := fpaov.values.([]*alerting_policy.PagerCursor)
	return res, ok
}

type ListAlertingPoliciesResponse_FieldSubPathArrayOfValues struct {
	ListAlertingPoliciesResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListAlertingPoliciesResponse_FieldPathArrayOfValues = (*ListAlertingPoliciesResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListAlertingPoliciesResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListAlertingPoliciesResponse_FieldSubPathArrayOfValues) AsAlertingPoliciesPathArrayOfValues() (alerting_policy.AlertingPolicy_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(alerting_policy.AlertingPolicy_FieldPathArrayOfValues)
	return res, ok
}

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

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

type WatchAlertingPolicyRequest_FieldPathSelector int32

const (
	WatchAlertingPolicyRequest_FieldPathSelectorName      WatchAlertingPolicyRequest_FieldPathSelector = 0
	WatchAlertingPolicyRequest_FieldPathSelectorFieldMask WatchAlertingPolicyRequest_FieldPathSelector = 1
	WatchAlertingPolicyRequest_FieldPathSelectorView      WatchAlertingPolicyRequest_FieldPathSelector = 2
)

func (s WatchAlertingPolicyRequest_FieldPathSelector) String() string {
	switch s {
	case WatchAlertingPolicyRequest_FieldPathSelectorName:
		return "name"
	case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchAlertingPolicyRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyRequest: %d", s))
	}
}

func BuildWatchAlertingPolicyRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchAlertingPolicyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchAlertingPolicyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &WatchAlertingPolicyRequest_FieldTerminalPath{selector: WatchAlertingPolicyRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchAlertingPolicyRequest_FieldTerminalPath{selector: WatchAlertingPolicyRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchAlertingPolicyRequest_FieldTerminalPath{selector: WatchAlertingPolicyRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchAlertingPolicyRequest", fp)
}

func ParseWatchAlertingPolicyRequest_FieldPath(rawField string) (WatchAlertingPolicyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchAlertingPolicyRequest_FieldPath(fp)
}

func MustParseWatchAlertingPolicyRequest_FieldPath(rawField string) WatchAlertingPolicyRequest_FieldPath {
	fp, err := ParseWatchAlertingPolicyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchAlertingPolicyRequest_FieldTerminalPath struct {
	selector WatchAlertingPolicyRequest_FieldPathSelector
}

var _ WatchAlertingPolicyRequest_FieldPath = (*WatchAlertingPolicyRequest_FieldTerminalPath)(nil)

func (fp *WatchAlertingPolicyRequest_FieldTerminalPath) Selector() WatchAlertingPolicyRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchAlertingPolicyRequest
func (fp *WatchAlertingPolicyRequest_FieldTerminalPath) Get(source *WatchAlertingPolicyRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchAlertingPolicyRequest_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchAlertingPolicyRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchAlertingPolicyRequest
func (fp *WatchAlertingPolicyRequest_FieldTerminalPath) GetSingle(source *WatchAlertingPolicyRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchAlertingPolicyRequest_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchAlertingPolicyRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchAlertingPolicyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchAlertingPolicyRequest_FieldPathSelectorName:
		return (*alerting_policy.Reference)(nil)
	case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return (*alerting_policy.AlertingPolicy_FieldMask)(nil)
	case WatchAlertingPolicyRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyRequest: %d", fp.selector))
	}
}

func (fp *WatchAlertingPolicyRequest_FieldTerminalPath) ClearValue(item *WatchAlertingPolicyRequest) {
	if item != nil {
		switch fp.selector {
		case WatchAlertingPolicyRequest_FieldPathSelectorName:
			item.Name = nil
		case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchAlertingPolicyRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchAlertingPolicyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchAlertingPolicyRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchAlertingPolicyRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchAlertingPolicyRequest_FieldPathSelectorName ||
		fp.selector == WatchAlertingPolicyRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchAlertingPolicyRequest_FieldPathSelectorView
}

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

func (fp *WatchAlertingPolicyRequest_FieldTerminalPath) WithIValue(value interface{}) WatchAlertingPolicyRequest_FieldPathValue {
	switch fp.selector {
	case WatchAlertingPolicyRequest_FieldPathSelectorName:
		return &WatchAlertingPolicyRequest_FieldTerminalPathValue{WatchAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.Reference)}
	case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return &WatchAlertingPolicyRequest_FieldTerminalPathValue{WatchAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy_FieldMask)}
	case WatchAlertingPolicyRequest_FieldPathSelectorView:
		return &WatchAlertingPolicyRequest_FieldTerminalPathValue{WatchAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyRequest: %d", fp.selector))
	}
}

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

func (fp *WatchAlertingPolicyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov := &WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues{WatchAlertingPolicyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchAlertingPolicyRequest_FieldPathSelectorName:
		return &WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues{WatchAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.Reference)}
	case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return &WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues{WatchAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy_FieldMask)}
	case WatchAlertingPolicyRequest_FieldPathSelectorView:
		return &WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues{WatchAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchAlertingPolicyRequest_FieldPathValue(pathStr, valueStr string) WatchAlertingPolicyRequest_FieldPathValue {
	fpv, err := ParseWatchAlertingPolicyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchAlertingPolicyRequest_FieldTerminalPathValue struct {
	WatchAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPolicyRequest_FieldPathValue = (*WatchAlertingPolicyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchAlertingPolicyRequest' as interface{}
func (fpv *WatchAlertingPolicyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchAlertingPolicyRequest_FieldTerminalPathValue) AsNameValue() (*alerting_policy.Reference, bool) {
	res, ok := fpv.value.(*alerting_policy.Reference)
	return res, ok
}
func (fpv *WatchAlertingPolicyRequest_FieldTerminalPathValue) AsFieldMaskValue() (*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpv *WatchAlertingPolicyRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object WatchAlertingPolicyRequest
func (fpv *WatchAlertingPolicyRequest_FieldTerminalPathValue) SetTo(target **WatchAlertingPolicyRequest) {
	if *target == nil {
		*target = new(WatchAlertingPolicyRequest)
	}
	switch fpv.selector {
	case WatchAlertingPolicyRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*alerting_policy.Reference)
	case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	case WatchAlertingPolicyRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchAlertingPolicyRequest_FieldTerminalPathValue' with the value under path in 'WatchAlertingPolicyRequest'.
func (fpv *WatchAlertingPolicyRequest_FieldTerminalPathValue) CompareWith(source *WatchAlertingPolicyRequest) (int, bool) {
	switch fpv.selector {
	case WatchAlertingPolicyRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*alerting_policy.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchAlertingPolicyRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchAlertingPolicyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchAlertingPolicyRequest_FieldTerminalPathArrayItemValue struct {
	WatchAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPolicyRequest_FieldPathArrayItemValue = (*WatchAlertingPolicyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchAlertingPolicyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchAlertingPolicyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// WatchAlertingPolicyRequest_FieldPathArrayOfValues allows storing slice of values for WatchAlertingPolicyRequest fields according to their type
type WatchAlertingPolicyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchAlertingPolicyRequest_FieldPath
}

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

func MustParseWatchAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues struct {
	WatchAlertingPolicyRequest_FieldTerminalPath
	values interface{}
}

var _ WatchAlertingPolicyRequest_FieldPathArrayOfValues = (*WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchAlertingPolicyRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*alerting_policy.Reference) {
			values = append(values, v)
		}
	case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask) {
			values = append(values, v)
		}
	case WatchAlertingPolicyRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*alerting_policy.Reference, bool) {
	res, ok := fpaov.values.([]*alerting_policy.Reference)
	return res, ok
}
func (fpaov *WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpaov *WatchAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

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

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

type WatchAlertingPolicyResponse_FieldPathSelector int32

const (
	WatchAlertingPolicyResponse_FieldPathSelectorChange WatchAlertingPolicyResponse_FieldPathSelector = 0
)

func (s WatchAlertingPolicyResponse_FieldPathSelector) String() string {
	switch s {
	case WatchAlertingPolicyResponse_FieldPathSelectorChange:
		return "change"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyResponse: %d", s))
	}
}

func BuildWatchAlertingPolicyResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchAlertingPolicyResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchAlertingPolicyResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "change":
			return &WatchAlertingPolicyResponse_FieldTerminalPath{selector: WatchAlertingPolicyResponse_FieldPathSelectorChange}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchAlertingPolicyResponse", fp)
}

func ParseWatchAlertingPolicyResponse_FieldPath(rawField string) (WatchAlertingPolicyResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchAlertingPolicyResponse_FieldPath(fp)
}

func MustParseWatchAlertingPolicyResponse_FieldPath(rawField string) WatchAlertingPolicyResponse_FieldPath {
	fp, err := ParseWatchAlertingPolicyResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchAlertingPolicyResponse_FieldTerminalPath struct {
	selector WatchAlertingPolicyResponse_FieldPathSelector
}

var _ WatchAlertingPolicyResponse_FieldPath = (*WatchAlertingPolicyResponse_FieldTerminalPath)(nil)

func (fp *WatchAlertingPolicyResponse_FieldTerminalPath) Selector() WatchAlertingPolicyResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchAlertingPolicyResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchAlertingPolicyResponse_FieldPathSelectorChange:
		return (*alerting_policy.AlertingPolicyChange)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyResponse: %d", fp.selector))
	}
}

func (fp *WatchAlertingPolicyResponse_FieldTerminalPath) ClearValue(item *WatchAlertingPolicyResponse) {
	if item != nil {
		switch fp.selector {
		case WatchAlertingPolicyResponse_FieldPathSelectorChange:
			item.Change = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchAlertingPolicyResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchAlertingPolicyResponse))
}

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

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

func (fp *WatchAlertingPolicyResponse_FieldTerminalPath) WithIValue(value interface{}) WatchAlertingPolicyResponse_FieldPathValue {
	switch fp.selector {
	case WatchAlertingPolicyResponse_FieldPathSelectorChange:
		return &WatchAlertingPolicyResponse_FieldTerminalPathValue{WatchAlertingPolicyResponse_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicyChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyResponse: %d", fp.selector))
	}
}

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

func (fp *WatchAlertingPolicyResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchAlertingPolicyResponse_FieldPathArrayOfValues {
	fpaov := &WatchAlertingPolicyResponse_FieldTerminalPathArrayOfValues{WatchAlertingPolicyResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchAlertingPolicyResponse_FieldPathSelectorChange:
		return &WatchAlertingPolicyResponse_FieldTerminalPathArrayOfValues{WatchAlertingPolicyResponse_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicyChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchAlertingPolicyResponse_FieldPathValue(pathStr, valueStr string) WatchAlertingPolicyResponse_FieldPathValue {
	fpv, err := ParseWatchAlertingPolicyResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchAlertingPolicyResponse_FieldTerminalPathValue struct {
	WatchAlertingPolicyResponse_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPolicyResponse_FieldPathValue = (*WatchAlertingPolicyResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchAlertingPolicyResponse' as interface{}
func (fpv *WatchAlertingPolicyResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchAlertingPolicyResponse_FieldTerminalPathValue) AsChangeValue() (*alerting_policy.AlertingPolicyChange, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicyChange)
	return res, ok
}

// SetTo stores value for selected field for object WatchAlertingPolicyResponse
func (fpv *WatchAlertingPolicyResponse_FieldTerminalPathValue) SetTo(target **WatchAlertingPolicyResponse) {
	if *target == nil {
		*target = new(WatchAlertingPolicyResponse)
	}
	switch fpv.selector {
	case WatchAlertingPolicyResponse_FieldPathSelectorChange:
		(*target).Change = fpv.value.(*alerting_policy.AlertingPolicyChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPolicyResponse: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseWatchAlertingPolicyResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchAlertingPolicyResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchAlertingPolicyResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchAlertingPolicyResponse_FieldTerminalPathArrayItemValue struct {
	WatchAlertingPolicyResponse_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPolicyResponse_FieldPathArrayItemValue = (*WatchAlertingPolicyResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchAlertingPolicyResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchAlertingPolicyResponse) (interface{}, bool) {
	return nil, false
}

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

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

// WatchAlertingPolicyResponse_FieldPathArrayOfValues allows storing slice of values for WatchAlertingPolicyResponse fields according to their type
type WatchAlertingPolicyResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchAlertingPolicyResponse_FieldPath
}

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

func MustParseWatchAlertingPolicyResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchAlertingPolicyResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchAlertingPolicyResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchAlertingPolicyResponse_FieldTerminalPathArrayOfValues struct {
	WatchAlertingPolicyResponse_FieldTerminalPath
	values interface{}
}

var _ WatchAlertingPolicyResponse_FieldPathArrayOfValues = (*WatchAlertingPolicyResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchAlertingPolicyResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchAlertingPolicyResponse_FieldPathSelectorChange:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicyChange) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchAlertingPolicyResponse_FieldTerminalPathArrayOfValues) AsChangeArrayOfValues() ([]*alerting_policy.AlertingPolicyChange, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicyChange)
	return res, ok
}

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

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

type WatchAlertingPoliciesRequest_FieldPathSelector int32

const (
	WatchAlertingPoliciesRequest_FieldPathSelectorType         WatchAlertingPoliciesRequest_FieldPathSelector = 0
	WatchAlertingPoliciesRequest_FieldPathSelectorParent       WatchAlertingPoliciesRequest_FieldPathSelector = 1
	WatchAlertingPoliciesRequest_FieldPathSelectorPageSize     WatchAlertingPoliciesRequest_FieldPathSelector = 2
	WatchAlertingPoliciesRequest_FieldPathSelectorPageToken    WatchAlertingPoliciesRequest_FieldPathSelector = 3
	WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy      WatchAlertingPoliciesRequest_FieldPathSelector = 4
	WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken  WatchAlertingPoliciesRequest_FieldPathSelector = 5
	WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime WatchAlertingPoliciesRequest_FieldPathSelector = 6
	WatchAlertingPoliciesRequest_FieldPathSelectorFilter       WatchAlertingPoliciesRequest_FieldPathSelector = 7
	WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask    WatchAlertingPoliciesRequest_FieldPathSelector = 8
	WatchAlertingPoliciesRequest_FieldPathSelectorView         WatchAlertingPoliciesRequest_FieldPathSelector = 9
	WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize WatchAlertingPoliciesRequest_FieldPathSelector = 10
)

func (s WatchAlertingPoliciesRequest_FieldPathSelector) String() string {
	switch s {
	case WatchAlertingPoliciesRequest_FieldPathSelectorType:
		return "type"
	case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
		return "parent"
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return "page_size"
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return "page_token"
	case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
		return "starting_time"
	case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
		return "filter"
	case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchAlertingPoliciesRequest_FieldPathSelectorView:
		return "view"
	case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
		return "max_chunk_size"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesRequest: %d", s))
	}
}

func BuildWatchAlertingPoliciesRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchAlertingPoliciesRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchAlertingPoliciesRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorType}, nil
		case "parent":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken}, nil
		case "starting_time", "startingTime", "starting-time":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime}, nil
		case "filter":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorView}, nil
		case "max_chunk_size", "maxChunkSize", "max-chunk-size":
			return &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchAlertingPoliciesRequest", fp)
}

func ParseWatchAlertingPoliciesRequest_FieldPath(rawField string) (WatchAlertingPoliciesRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchAlertingPoliciesRequest_FieldPath(fp)
}

func MustParseWatchAlertingPoliciesRequest_FieldPath(rawField string) WatchAlertingPoliciesRequest_FieldPath {
	fp, err := ParseWatchAlertingPoliciesRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchAlertingPoliciesRequest_FieldTerminalPath struct {
	selector WatchAlertingPoliciesRequest_FieldPathSelector
}

var _ WatchAlertingPoliciesRequest_FieldPath = (*WatchAlertingPoliciesRequest_FieldTerminalPath)(nil)

func (fp *WatchAlertingPoliciesRequest_FieldTerminalPath) Selector() WatchAlertingPoliciesRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchAlertingPoliciesRequest
func (fp *WatchAlertingPoliciesRequest_FieldTerminalPath) Get(source *WatchAlertingPoliciesRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchAlertingPoliciesRequest_FieldPathSelectorType:
			values = append(values, source.Type)
		case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
			if source.StartingTime != nil {
				values = append(values, source.StartingTime)
			}
		case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchAlertingPoliciesRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
			values = append(values, source.MaxChunkSize)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchAlertingPoliciesRequest
func (fp *WatchAlertingPoliciesRequest_FieldTerminalPath) GetSingle(source *WatchAlertingPoliciesRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchAlertingPoliciesRequest_FieldPathSelectorType:
		return source.GetType(), source != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
		res := source.GetStartingTime()
		return res, res != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
		return source.GetMaxChunkSize(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchAlertingPoliciesRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchAlertingPoliciesRequest_FieldPathSelectorType:
		return watch_type.WatchType_STATEFUL
	case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
		return (*alerting_policy.ParentReference)(nil)
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return int32(0)
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return (*alerting_policy.PagerCursor)(nil)
	case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return (*alerting_policy.OrderBy)(nil)
	case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
		return ""
	case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
		return (*timestamp.Timestamp)(nil)
	case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
		return (*alerting_policy.Filter)(nil)
	case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return (*alerting_policy.AlertingPolicy_FieldMask)(nil)
	case WatchAlertingPoliciesRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesRequest: %d", fp.selector))
	}
}

func (fp *WatchAlertingPoliciesRequest_FieldTerminalPath) ClearValue(item *WatchAlertingPoliciesRequest) {
	if item != nil {
		switch fp.selector {
		case WatchAlertingPoliciesRequest_FieldPathSelectorType:
			item.Type = watch_type.WatchType_STATEFUL
		case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
			item.Parent = nil
		case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
			item.StartingTime = nil
		case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchAlertingPoliciesRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
			item.MaxChunkSize = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchAlertingPoliciesRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchAlertingPoliciesRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchAlertingPoliciesRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorType ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorParent ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorPageSize ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorPageToken ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorFilter ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorView ||
		fp.selector == WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize
}

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

func (fp *WatchAlertingPoliciesRequest_FieldTerminalPath) WithIValue(value interface{}) WatchAlertingPoliciesRequest_FieldPathValue {
	switch fp.selector {
	case WatchAlertingPoliciesRequest_FieldPathSelectorType:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(watch_type.WatchType)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.ParentReference)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.PagerCursor)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.OrderBy)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(string)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*timestamp.Timestamp)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.Filter)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy_FieldMask)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorView:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathValue{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesRequest: %d", fp.selector))
	}
}

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

func (fp *WatchAlertingPoliciesRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchAlertingPoliciesRequest_FieldPathArrayOfValues {
	fpaov := &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchAlertingPoliciesRequest_FieldPathSelectorType:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]watch_type.WatchType)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.ParentReference)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.PagerCursor)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.OrderBy)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*timestamp.Timestamp)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.Filter)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy_FieldMask)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorView:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
		return &WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchAlertingPoliciesRequest_FieldPathValue(pathStr, valueStr string) WatchAlertingPoliciesRequest_FieldPathValue {
	fpv, err := ParseWatchAlertingPoliciesRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchAlertingPoliciesRequest_FieldTerminalPathValue struct {
	WatchAlertingPoliciesRequest_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPoliciesRequest_FieldPathValue = (*WatchAlertingPoliciesRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchAlertingPoliciesRequest' as interface{}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsTypeValue() (watch_type.WatchType, bool) {
	res, ok := fpv.value.(watch_type.WatchType)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsParentValue() (*alerting_policy.ParentReference, bool) {
	res, ok := fpv.value.(*alerting_policy.ParentReference)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsPageSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsPageTokenValue() (*alerting_policy.PagerCursor, bool) {
	res, ok := fpv.value.(*alerting_policy.PagerCursor)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsOrderByValue() (*alerting_policy.OrderBy, bool) {
	res, ok := fpv.value.(*alerting_policy.OrderBy)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsStartingTimeValue() (*timestamp.Timestamp, bool) {
	res, ok := fpv.value.(*timestamp.Timestamp)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsFilterValue() (*alerting_policy.Filter, bool) {
	res, ok := fpv.value.(*alerting_policy.Filter)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsFieldMaskValue() (*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) AsMaxChunkSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object WatchAlertingPoliciesRequest
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) SetTo(target **WatchAlertingPoliciesRequest) {
	if *target == nil {
		*target = new(WatchAlertingPoliciesRequest)
	}
	switch fpv.selector {
	case WatchAlertingPoliciesRequest_FieldPathSelectorType:
		(*target).Type = fpv.value.(watch_type.WatchType)
	case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*alerting_policy.ParentReference)
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*alerting_policy.PagerCursor)
	case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*alerting_policy.OrderBy)
	case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
		(*target).StartingTime = fpv.value.(*timestamp.Timestamp)
	case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*alerting_policy.Filter)
	case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	case WatchAlertingPoliciesRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
		(*target).MaxChunkSize = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchAlertingPoliciesRequest_FieldTerminalPathValue' with the value under path in 'WatchAlertingPoliciesRequest'.
func (fpv *WatchAlertingPoliciesRequest_FieldTerminalPathValue) CompareWith(source *WatchAlertingPoliciesRequest) (int, bool) {
	switch fpv.selector {
	case WatchAlertingPoliciesRequest_FieldPathSelectorType:
		leftValue := fpv.value.(watch_type.WatchType)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*alerting_policy.ParentReference)
		rightValue := source.GetParent()
		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 WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetPageSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
		return 0, false
	case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		return 0, false
	case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
		leftValue := fpv.value.(string)
		rightValue := source.GetResumeToken()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
		leftValue := fpv.value.(*timestamp.Timestamp)
		rightValue := source.GetStartingTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
		return 0, false
	case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchAlertingPoliciesRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetMaxChunkSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchAlertingPoliciesRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchAlertingPoliciesRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchAlertingPoliciesRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchAlertingPoliciesRequest_FieldTerminalPathArrayItemValue struct {
	WatchAlertingPoliciesRequest_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPoliciesRequest_FieldPathArrayItemValue = (*WatchAlertingPoliciesRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchAlertingPoliciesRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchAlertingPoliciesRequest) (interface{}, bool) {
	return nil, false
}

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

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

// WatchAlertingPoliciesRequest_FieldPathArrayOfValues allows storing slice of values for WatchAlertingPoliciesRequest fields according to their type
type WatchAlertingPoliciesRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchAlertingPoliciesRequest_FieldPath
}

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

func MustParseWatchAlertingPoliciesRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchAlertingPoliciesRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchAlertingPoliciesRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues struct {
	WatchAlertingPoliciesRequest_FieldTerminalPath
	values interface{}
}

var _ WatchAlertingPoliciesRequest_FieldPathArrayOfValues = (*WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchAlertingPoliciesRequest_FieldPathSelectorType:
		for _, v := range fpaov.values.([]watch_type.WatchType) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*alerting_policy.ParentReference) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*alerting_policy.PagerCursor) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*alerting_policy.OrderBy) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
		for _, v := range fpaov.values.([]*timestamp.Timestamp) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*alerting_policy.Filter) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]watch_type.WatchType, bool) {
	res, ok := fpaov.values.([]watch_type.WatchType)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*alerting_policy.ParentReference, bool) {
	res, ok := fpaov.values.([]*alerting_policy.ParentReference)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*alerting_policy.PagerCursor, bool) {
	res, ok := fpaov.values.([]*alerting_policy.PagerCursor)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*alerting_policy.OrderBy, bool) {
	res, ok := fpaov.values.([]*alerting_policy.OrderBy)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsStartingTimeArrayOfValues() ([]*timestamp.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamp.Timestamp)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*alerting_policy.Filter, bool) {
	res, ok := fpaov.values.([]*alerting_policy.Filter)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesRequest_FieldTerminalPathArrayOfValues) AsMaxChunkSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

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

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

type WatchAlertingPoliciesResponse_FieldPathSelector int32

const (
	WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges WatchAlertingPoliciesResponse_FieldPathSelector = 0
	WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent             WatchAlertingPoliciesResponse_FieldPathSelector = 1
	WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange       WatchAlertingPoliciesResponse_FieldPathSelector = 2
	WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken           WatchAlertingPoliciesResponse_FieldPathSelector = 3
	WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize          WatchAlertingPoliciesResponse_FieldPathSelector = 4
	WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset           WatchAlertingPoliciesResponse_FieldPathSelector = 5
	WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset           WatchAlertingPoliciesResponse_FieldPathSelector = 6
)

func (s WatchAlertingPoliciesResponse_FieldPathSelector) String() string {
	switch s {
	case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
		return "alerting_policy_changes"
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
		return "is_current"
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		return "page_token_change"
	case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
		return "snapshot_size"
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
		return "is_soft_reset"
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
		return "is_hard_reset"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", s))
	}
}

func BuildWatchAlertingPoliciesResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchAlertingPoliciesResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchAlertingPoliciesResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "alerting_policy_changes", "alertingPolicyChanges", "alerting-policy-changes":
			return &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges}, nil
		case "is_current", "isCurrent", "is-current":
			return &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent}, nil
		case "page_token_change", "pageTokenChange", "page-token-change":
			return &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken}, nil
		case "snapshot_size", "snapshotSize", "snapshot-size":
			return &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize}, nil
		case "is_soft_reset", "isSoftReset", "is-soft-reset":
			return &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset}, nil
		case "is_hard_reset", "isHardReset", "is-hard-reset":
			return &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset}, nil
		}
	} else {
		switch fp[0] {
		case "page_token_change", "pageTokenChange", "page-token-change":
			if subpath, err := BuildWatchAlertingPoliciesResponsePageTokenChange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &WatchAlertingPoliciesResponse_FieldSubPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchAlertingPoliciesResponse", fp)
}

func ParseWatchAlertingPoliciesResponse_FieldPath(rawField string) (WatchAlertingPoliciesResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchAlertingPoliciesResponse_FieldPath(fp)
}

func MustParseWatchAlertingPoliciesResponse_FieldPath(rawField string) WatchAlertingPoliciesResponse_FieldPath {
	fp, err := ParseWatchAlertingPoliciesResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchAlertingPoliciesResponse_FieldTerminalPath struct {
	selector WatchAlertingPoliciesResponse_FieldPathSelector
}

var _ WatchAlertingPoliciesResponse_FieldPath = (*WatchAlertingPoliciesResponse_FieldTerminalPath)(nil)

func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) Selector() WatchAlertingPoliciesResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchAlertingPoliciesResponse
func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) Get(source *WatchAlertingPoliciesResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
			for _, value := range source.GetAlertingPolicyChanges() {
				values = append(values, value)
			}
		case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
			values = append(values, source.IsCurrent)
		case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
			if source.PageTokenChange != nil {
				values = append(values, source.PageTokenChange)
			}
		case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
			values = append(values, source.SnapshotSize)
		case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
			values = append(values, source.IsSoftReset)
		case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
			values = append(values, source.IsHardReset)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchAlertingPoliciesResponse
func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) GetSingle(source *WatchAlertingPoliciesResponse) (interface{}, bool) {
	switch fp.selector {
	case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
		res := source.GetAlertingPolicyChanges()
		return res, res != nil
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
		return source.GetIsCurrent(), source != nil
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		res := source.GetPageTokenChange()
		return res, res != nil
	case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
		return source.GetSnapshotSize(), source != nil
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
		return source.GetIsSoftReset(), source != nil
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
		return source.GetIsHardReset(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
		return ([]*alerting_policy.AlertingPolicyChange)(nil)
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
		return false
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		return (*WatchAlertingPoliciesResponse_PageTokenChange)(nil)
	case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
		return ""
	case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
		return int64(0)
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
		return false
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fp.selector))
	}
}

func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) ClearValue(item *WatchAlertingPoliciesResponse) {
	if item != nil {
		switch fp.selector {
		case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
			item.AlertingPolicyChanges = nil
		case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
			item.IsCurrent = false
		case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
			item.PageTokenChange = nil
		case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
			item.SnapshotSize = int64(0)
		case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
			item.IsSoftReset = false
		case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
			item.IsHardReset = false
		default:
			panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchAlertingPoliciesResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges ||
		fp.selector == WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent ||
		fp.selector == WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken ||
		fp.selector == WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize ||
		fp.selector == WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset ||
		fp.selector == WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset
}

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

func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) WithIValue(value interface{}) WatchAlertingPoliciesResponse_FieldPathValue {
	switch fp.selector {
	case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathValue{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.([]*alerting_policy.AlertingPolicyChange)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathValue{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathValue{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(*WatchAlertingPoliciesResponse_PageTokenChange)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathValue{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(string)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathValue{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(int64)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathValue{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathValue{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fp.selector))
	}
}

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

func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchAlertingPoliciesResponse_FieldPathArrayOfValues {
	fpaov := &WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([][]*alerting_policy.AlertingPolicyChange)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([]*WatchAlertingPoliciesResponse_PageTokenChange)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([]int64)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *WatchAlertingPoliciesResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchAlertingPoliciesResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
		return &WatchAlertingPoliciesResponse_FieldTerminalPathArrayItemValue{WatchAlertingPoliciesResponse_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicyChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fp.selector))
	}
}

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

type WatchAlertingPoliciesResponse_FieldSubPath struct {
	selector WatchAlertingPoliciesResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ WatchAlertingPoliciesResponse_FieldPath = (*WatchAlertingPoliciesResponse_FieldSubPath)(nil)

func (fps *WatchAlertingPoliciesResponse_FieldSubPath) Selector() WatchAlertingPoliciesResponse_FieldPathSelector {
	return fps.selector
}
func (fps *WatchAlertingPoliciesResponse_FieldSubPath) AsPageTokenChangeSubPath() (WatchAlertingPoliciesResponsePageTokenChange_FieldPath, bool) {
	res, ok := fps.subPath.(WatchAlertingPoliciesResponsePageTokenChange_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source WatchAlertingPoliciesResponse
func (fps *WatchAlertingPoliciesResponse_FieldSubPath) Get(source *WatchAlertingPoliciesResponse) (values []interface{}) {
	if asPageTokenChangeFieldPath, ok := fps.AsPageTokenChangeSubPath(); ok {
		values = append(values, asPageTokenChangeFieldPath.Get(source.GetPageTokenChange())...)
	} else {
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fps.selector))
	}
	return
}

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

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

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

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

func (fps *WatchAlertingPoliciesResponse_FieldSubPath) ClearValue(item *WatchAlertingPoliciesResponse) {
	if item != nil {
		switch fps.selector {
		case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
			fps.subPath.ClearValueRaw(item.PageTokenChange)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fps.selector))
		}
	}
}

func (fps *WatchAlertingPoliciesResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*WatchAlertingPoliciesResponse))
}

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

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

func (fps *WatchAlertingPoliciesResponse_FieldSubPath) WithIValue(value interface{}) WatchAlertingPoliciesResponse_FieldPathValue {
	return &WatchAlertingPoliciesResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *WatchAlertingPoliciesResponse_FieldSubPath) WithIArrayOfValues(values interface{}) WatchAlertingPoliciesResponse_FieldPathArrayOfValues {
	return &WatchAlertingPoliciesResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *WatchAlertingPoliciesResponse_FieldSubPath) WithIArrayItemValue(value interface{}) WatchAlertingPoliciesResponse_FieldPathArrayItemValue {
	return &WatchAlertingPoliciesResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseWatchAlertingPoliciesResponse_FieldPathValue(pathStr, valueStr string) WatchAlertingPoliciesResponse_FieldPathValue {
	fpv, err := ParseWatchAlertingPoliciesResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchAlertingPoliciesResponse_FieldTerminalPathValue struct {
	WatchAlertingPoliciesResponse_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPoliciesResponse_FieldPathValue = (*WatchAlertingPoliciesResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchAlertingPoliciesResponse' as interface{}
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) AsAlertingPolicyChangesValue() ([]*alerting_policy.AlertingPolicyChange, bool) {
	res, ok := fpv.value.([]*alerting_policy.AlertingPolicyChange)
	return res, ok
}
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) AsIsCurrentValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) AsPageTokenChangeValue() (*WatchAlertingPoliciesResponse_PageTokenChange, bool) {
	res, ok := fpv.value.(*WatchAlertingPoliciesResponse_PageTokenChange)
	return res, ok
}
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) AsSnapshotSizeValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) AsIsSoftResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) AsIsHardResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object WatchAlertingPoliciesResponse
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) SetTo(target **WatchAlertingPoliciesResponse) {
	if *target == nil {
		*target = new(WatchAlertingPoliciesResponse)
	}
	switch fpv.selector {
	case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
		(*target).AlertingPolicyChanges = fpv.value.([]*alerting_policy.AlertingPolicyChange)
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
		(*target).IsCurrent = fpv.value.(bool)
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		(*target).PageTokenChange = fpv.value.(*WatchAlertingPoliciesResponse_PageTokenChange)
	case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
		(*target).SnapshotSize = fpv.value.(int64)
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
		(*target).IsSoftReset = fpv.value.(bool)
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
		(*target).IsHardReset = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchAlertingPoliciesResponse_FieldTerminalPathValue' with the value under path in 'WatchAlertingPoliciesResponse'.
func (fpv *WatchAlertingPoliciesResponse_FieldTerminalPathValue) CompareWith(source *WatchAlertingPoliciesResponse) (int, bool) {
	switch fpv.selector {
	case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
		return 0, false
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsCurrent()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		return 0, false
	case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
		leftValue := fpv.value.(string)
		rightValue := source.GetResumeToken()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
		leftValue := fpv.value.(int64)
		rightValue := source.GetSnapshotSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsSoftReset()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsHardReset()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fpv.selector))
	}
}

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

type WatchAlertingPoliciesResponse_FieldSubPathValue struct {
	WatchAlertingPoliciesResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ WatchAlertingPoliciesResponse_FieldPathValue = (*WatchAlertingPoliciesResponse_FieldSubPathValue)(nil)

func (fpvs *WatchAlertingPoliciesResponse_FieldSubPathValue) AsPageTokenChangePathValue() (WatchAlertingPoliciesResponsePageTokenChange_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(WatchAlertingPoliciesResponsePageTokenChange_FieldPathValue)
	return res, ok
}

func (fpvs *WatchAlertingPoliciesResponse_FieldSubPathValue) SetTo(target **WatchAlertingPoliciesResponse) {
	if *target == nil {
		*target = new(WatchAlertingPoliciesResponse)
	}
	switch fpvs.Selector() {
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		fpvs.subPathValue.(WatchAlertingPoliciesResponsePageTokenChange_FieldPathValue).SetTo(&(*target).PageTokenChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *WatchAlertingPoliciesResponse_FieldSubPathValue) CompareWith(source *WatchAlertingPoliciesResponse) (int, bool) {
	switch fpvs.Selector() {
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		return fpvs.subPathValue.(WatchAlertingPoliciesResponsePageTokenChange_FieldPathValue).CompareWith(source.GetPageTokenChange())
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseWatchAlertingPoliciesResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchAlertingPoliciesResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchAlertingPoliciesResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchAlertingPoliciesResponse_FieldTerminalPathArrayItemValue struct {
	WatchAlertingPoliciesResponse_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPoliciesResponse_FieldPathArrayItemValue = (*WatchAlertingPoliciesResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchAlertingPoliciesResponse as interface{}
func (fpaiv *WatchAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *WatchAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) AsAlertingPolicyChangesItemValue() (*alerting_policy.AlertingPolicyChange, bool) {
	res, ok := fpaiv.value.(*alerting_policy.AlertingPolicyChange)
	return res, ok
}

func (fpaiv *WatchAlertingPoliciesResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchAlertingPoliciesResponse) (interface{}, bool) {
	return nil, false
}

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

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

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

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

// WatchAlertingPoliciesResponse_FieldPathArrayOfValues allows storing slice of values for WatchAlertingPoliciesResponse fields according to their type
type WatchAlertingPoliciesResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchAlertingPoliciesResponse_FieldPath
}

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

func MustParseWatchAlertingPoliciesResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchAlertingPoliciesResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchAlertingPoliciesResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues struct {
	WatchAlertingPoliciesResponse_FieldTerminalPath
	values interface{}
}

var _ WatchAlertingPoliciesResponse_FieldPathArrayOfValues = (*WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
		for _, v := range fpaov.values.([][]*alerting_policy.AlertingPolicyChange) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
		for _, v := range fpaov.values.([]*WatchAlertingPoliciesResponse_PageTokenChange) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsAlertingPolicyChangesArrayOfValues() ([][]*alerting_policy.AlertingPolicyChange, bool) {
	res, ok := fpaov.values.([][]*alerting_policy.AlertingPolicyChange)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsIsCurrentArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsPageTokenChangeArrayOfValues() ([]*WatchAlertingPoliciesResponse_PageTokenChange, bool) {
	res, ok := fpaov.values.([]*WatchAlertingPoliciesResponse_PageTokenChange)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsSnapshotSizeArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsIsSoftResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesResponse_FieldTerminalPathArrayOfValues) AsIsHardResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type WatchAlertingPoliciesResponse_FieldSubPathArrayOfValues struct {
	WatchAlertingPoliciesResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ WatchAlertingPoliciesResponse_FieldPathArrayOfValues = (*WatchAlertingPoliciesResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *WatchAlertingPoliciesResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *WatchAlertingPoliciesResponse_FieldSubPathArrayOfValues) AsPageTokenChangePathArrayOfValues() (WatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(WatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayOfValues)
	return res, ok
}

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

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

type WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelector int32

const (
	WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelector = 0
	WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelector = 1
)

func (s WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelector) String() string {
	switch s {
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return "next_page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse_PageTokenChange: %d", s))
	}
}

func BuildWatchAlertingPoliciesResponsePageTokenChange_FieldPath(fp gotenobject.RawFieldPath) (WatchAlertingPoliciesResponsePageTokenChange_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchAlertingPoliciesResponse_PageTokenChange")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath{selector: WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath{selector: WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchAlertingPoliciesResponse_PageTokenChange", fp)
}

func ParseWatchAlertingPoliciesResponsePageTokenChange_FieldPath(rawField string) (WatchAlertingPoliciesResponsePageTokenChange_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchAlertingPoliciesResponsePageTokenChange_FieldPath(fp)
}

func MustParseWatchAlertingPoliciesResponsePageTokenChange_FieldPath(rawField string) WatchAlertingPoliciesResponsePageTokenChange_FieldPath {
	fp, err := ParseWatchAlertingPoliciesResponsePageTokenChange_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath struct {
	selector WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelector
}

var _ WatchAlertingPoliciesResponsePageTokenChange_FieldPath = (*WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath)(nil)

func (fp *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath) Selector() WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return (*alerting_policy.PagerCursor)(nil)
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return (*alerting_policy.PagerCursor)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath) ClearValue(item *WatchAlertingPoliciesResponse_PageTokenChange) {
	if item != nil {
		switch fp.selector {
		case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse_PageTokenChange: %d", fp.selector))
		}
	}
}

func (fp *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchAlertingPoliciesResponse_PageTokenChange))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken ||
		fp.selector == WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken
}

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

func (fp *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath) WithIValue(value interface{}) WatchAlertingPoliciesResponsePageTokenChange_FieldPathValue {
	switch fp.selector {
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathValue{WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*alerting_policy.PagerCursor)}
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathValue{WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*alerting_policy.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse_PageTokenChange: %d", fp.selector))
	}
}

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

func (fp *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov := &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*alerting_policy.PagerCursor)}
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*alerting_policy.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse_PageTokenChange: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// WatchAlertingPoliciesResponsePageTokenChange_FieldPathValue allows storing values for PageTokenChange fields according to their type
type WatchAlertingPoliciesResponsePageTokenChange_FieldPathValue interface {
	WatchAlertingPoliciesResponsePageTokenChange_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **WatchAlertingPoliciesResponse_PageTokenChange)
	CompareWith(*WatchAlertingPoliciesResponse_PageTokenChange) (cmp int, comparable bool)
}

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

func MustParseWatchAlertingPoliciesResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) WatchAlertingPoliciesResponsePageTokenChange_FieldPathValue {
	fpv, err := ParseWatchAlertingPoliciesResponsePageTokenChange_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathValue struct {
	WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPoliciesResponsePageTokenChange_FieldPathValue = (*WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PageTokenChange' as interface{}
func (fpv *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathValue) AsPrevPageTokenValue() (*alerting_policy.PagerCursor, bool) {
	res, ok := fpv.value.(*alerting_policy.PagerCursor)
	return res, ok
}
func (fpv *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathValue) AsNextPageTokenValue() (*alerting_policy.PagerCursor, bool) {
	res, ok := fpv.value.(*alerting_policy.PagerCursor)
	return res, ok
}

// SetTo stores value for selected field for object PageTokenChange
func (fpv *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathValue) SetTo(target **WatchAlertingPoliciesResponse_PageTokenChange) {
	if *target == nil {
		*target = new(WatchAlertingPoliciesResponse_PageTokenChange)
	}
	switch fpv.selector {
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*alerting_policy.PagerCursor)
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*alerting_policy.PagerCursor)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchAlertingPoliciesResponse_PageTokenChange: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseWatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) WatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayItemValue struct {
	WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayItemValue = (*WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayItemValue) GetSingle(source *WatchAlertingPoliciesResponse_PageTokenChange) (interface{}, bool) {
	return nil, false
}

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

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

// WatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayOfValues allows storing slice of values for PageTokenChange fields according to their type
type WatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchAlertingPoliciesResponsePageTokenChange_FieldPath
}

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

func MustParseWatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) WatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov, err := ParseWatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayOfValues struct {
	WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath
	values interface{}
}

var _ WatchAlertingPoliciesResponsePageTokenChange_FieldPathArrayOfValues = (*WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*alerting_policy.PagerCursor) {
			values = append(values, v)
		}
	case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*alerting_policy.PagerCursor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*alerting_policy.PagerCursor, bool) {
	res, ok := fpaov.values.([]*alerting_policy.PagerCursor)
	return res, ok
}
func (fpaov *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*alerting_policy.PagerCursor, bool) {
	res, ok := fpaov.values.([]*alerting_policy.PagerCursor)
	return res, ok
}

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

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

type CreateAlertingPolicyRequest_FieldPathSelector int32

const (
	CreateAlertingPolicyRequest_FieldPathSelectorParent         CreateAlertingPolicyRequest_FieldPathSelector = 0
	CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy CreateAlertingPolicyRequest_FieldPathSelector = 1
)

func (s CreateAlertingPolicyRequest_FieldPathSelector) String() string {
	switch s {
	case CreateAlertingPolicyRequest_FieldPathSelectorParent:
		return "parent"
	case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return "alerting_policy"
	default:
		panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", s))
	}
}

func BuildCreateAlertingPolicyRequest_FieldPath(fp gotenobject.RawFieldPath) (CreateAlertingPolicyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreateAlertingPolicyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &CreateAlertingPolicyRequest_FieldTerminalPath{selector: CreateAlertingPolicyRequest_FieldPathSelectorParent}, nil
		case "alerting_policy", "alertingPolicy", "alerting-policy":
			return &CreateAlertingPolicyRequest_FieldTerminalPath{selector: CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy}, nil
		}
	} else {
		switch fp[0] {
		case "alerting_policy", "alertingPolicy", "alerting-policy":
			if subpath, err := alerting_policy.BuildAlertingPolicy_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateAlertingPolicyRequest_FieldSubPath{selector: CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreateAlertingPolicyRequest", fp)
}

func ParseCreateAlertingPolicyRequest_FieldPath(rawField string) (CreateAlertingPolicyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreateAlertingPolicyRequest_FieldPath(fp)
}

func MustParseCreateAlertingPolicyRequest_FieldPath(rawField string) CreateAlertingPolicyRequest_FieldPath {
	fp, err := ParseCreateAlertingPolicyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreateAlertingPolicyRequest_FieldTerminalPath struct {
	selector CreateAlertingPolicyRequest_FieldPathSelector
}

var _ CreateAlertingPolicyRequest_FieldPath = (*CreateAlertingPolicyRequest_FieldTerminalPath)(nil)

func (fp *CreateAlertingPolicyRequest_FieldTerminalPath) Selector() CreateAlertingPolicyRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *CreateAlertingPolicyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreateAlertingPolicyRequest_FieldPathSelectorParent:
		return (*alerting_policy.ParentReference)(nil)
	case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return (*alerting_policy.AlertingPolicy)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fp.selector))
	}
}

func (fp *CreateAlertingPolicyRequest_FieldTerminalPath) ClearValue(item *CreateAlertingPolicyRequest) {
	if item != nil {
		switch fp.selector {
		case CreateAlertingPolicyRequest_FieldPathSelectorParent:
			item.Parent = nil
		case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
			item.AlertingPolicy = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fp.selector))
		}
	}
}

func (fp *CreateAlertingPolicyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreateAlertingPolicyRequest))
}

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

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

func (fp *CreateAlertingPolicyRequest_FieldTerminalPath) WithIValue(value interface{}) CreateAlertingPolicyRequest_FieldPathValue {
	switch fp.selector {
	case CreateAlertingPolicyRequest_FieldPathSelectorParent:
		return &CreateAlertingPolicyRequest_FieldTerminalPathValue{CreateAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.ParentReference)}
	case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return &CreateAlertingPolicyRequest_FieldTerminalPathValue{CreateAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fp.selector))
	}
}

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

func (fp *CreateAlertingPolicyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreateAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov := &CreateAlertingPolicyRequest_FieldTerminalPathArrayOfValues{CreateAlertingPolicyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreateAlertingPolicyRequest_FieldPathSelectorParent:
		return &CreateAlertingPolicyRequest_FieldTerminalPathArrayOfValues{CreateAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.ParentReference)}
	case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return &CreateAlertingPolicyRequest_FieldTerminalPathArrayOfValues{CreateAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type CreateAlertingPolicyRequest_FieldSubPath struct {
	selector CreateAlertingPolicyRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreateAlertingPolicyRequest_FieldPath = (*CreateAlertingPolicyRequest_FieldSubPath)(nil)

func (fps *CreateAlertingPolicyRequest_FieldSubPath) Selector() CreateAlertingPolicyRequest_FieldPathSelector {
	return fps.selector
}
func (fps *CreateAlertingPolicyRequest_FieldSubPath) AsAlertingPolicySubPath() (alerting_policy.AlertingPolicy_FieldPath, bool) {
	res, ok := fps.subPath.(alerting_policy.AlertingPolicy_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source CreateAlertingPolicyRequest
func (fps *CreateAlertingPolicyRequest_FieldSubPath) Get(source *CreateAlertingPolicyRequest) (values []interface{}) {
	if asAlertingPolicyFieldPath, ok := fps.AsAlertingPolicySubPath(); ok {
		values = append(values, asAlertingPolicyFieldPath.Get(source.GetAlertingPolicy())...)
	} else {
		panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fps.selector))
	}
	return
}

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

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

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

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

func (fps *CreateAlertingPolicyRequest_FieldSubPath) ClearValue(item *CreateAlertingPolicyRequest) {
	if item != nil {
		switch fps.selector {
		case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
			fps.subPath.ClearValueRaw(item.AlertingPolicy)
		default:
			panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fps.selector))
		}
	}
}

func (fps *CreateAlertingPolicyRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreateAlertingPolicyRequest))
}

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

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

func (fps *CreateAlertingPolicyRequest_FieldSubPath) WithIValue(value interface{}) CreateAlertingPolicyRequest_FieldPathValue {
	return &CreateAlertingPolicyRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *CreateAlertingPolicyRequest_FieldSubPath) WithIArrayOfValues(values interface{}) CreateAlertingPolicyRequest_FieldPathArrayOfValues {
	return &CreateAlertingPolicyRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *CreateAlertingPolicyRequest_FieldSubPath) WithIArrayItemValue(value interface{}) CreateAlertingPolicyRequest_FieldPathArrayItemValue {
	return &CreateAlertingPolicyRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseCreateAlertingPolicyRequest_FieldPathValue(pathStr, valueStr string) CreateAlertingPolicyRequest_FieldPathValue {
	fpv, err := ParseCreateAlertingPolicyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreateAlertingPolicyRequest_FieldTerminalPathValue struct {
	CreateAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ CreateAlertingPolicyRequest_FieldPathValue = (*CreateAlertingPolicyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreateAlertingPolicyRequest' as interface{}
func (fpv *CreateAlertingPolicyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreateAlertingPolicyRequest_FieldTerminalPathValue) AsParentValue() (*alerting_policy.ParentReference, bool) {
	res, ok := fpv.value.(*alerting_policy.ParentReference)
	return res, ok
}
func (fpv *CreateAlertingPolicyRequest_FieldTerminalPathValue) AsAlertingPolicyValue() (*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy)
	return res, ok
}

// SetTo stores value for selected field for object CreateAlertingPolicyRequest
func (fpv *CreateAlertingPolicyRequest_FieldTerminalPathValue) SetTo(target **CreateAlertingPolicyRequest) {
	if *target == nil {
		*target = new(CreateAlertingPolicyRequest)
	}
	switch fpv.selector {
	case CreateAlertingPolicyRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*alerting_policy.ParentReference)
	case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		(*target).AlertingPolicy = fpv.value.(*alerting_policy.AlertingPolicy)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'CreateAlertingPolicyRequest_FieldTerminalPathValue' with the value under path in 'CreateAlertingPolicyRequest'.
func (fpv *CreateAlertingPolicyRequest_FieldTerminalPathValue) CompareWith(source *CreateAlertingPolicyRequest) (int, bool) {
	switch fpv.selector {
	case CreateAlertingPolicyRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*alerting_policy.ParentReference)
		rightValue := source.GetParent()
		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 CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fpv.selector))
	}
}

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

type CreateAlertingPolicyRequest_FieldSubPathValue struct {
	CreateAlertingPolicyRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreateAlertingPolicyRequest_FieldPathValue = (*CreateAlertingPolicyRequest_FieldSubPathValue)(nil)

func (fpvs *CreateAlertingPolicyRequest_FieldSubPathValue) AsAlertingPolicyPathValue() (alerting_policy.AlertingPolicy_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue)
	return res, ok
}

func (fpvs *CreateAlertingPolicyRequest_FieldSubPathValue) SetTo(target **CreateAlertingPolicyRequest) {
	if *target == nil {
		*target = new(CreateAlertingPolicyRequest)
	}
	switch fpvs.Selector() {
	case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue).SetTo(&(*target).AlertingPolicy)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *CreateAlertingPolicyRequest_FieldSubPathValue) CompareWith(source *CreateAlertingPolicyRequest) (int, bool) {
	switch fpvs.Selector() {
	case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue).CompareWith(source.GetAlertingPolicy())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateAlertingPolicyRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseCreateAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr string) CreateAlertingPolicyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseCreateAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreateAlertingPolicyRequest_FieldTerminalPathArrayItemValue struct {
	CreateAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ CreateAlertingPolicyRequest_FieldPathArrayItemValue = (*CreateAlertingPolicyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *CreateAlertingPolicyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *CreateAlertingPolicyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *CreateAlertingPolicyRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *CreateAlertingPolicyRequest_FieldSubPathArrayItemValue) AsAlertingPolicyPathItemValue() (alerting_policy.AlertingPolicy_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(alerting_policy.AlertingPolicy_FieldPathArrayItemValue)
	return res, ok
}

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

// CreateAlertingPolicyRequest_FieldPathArrayOfValues allows storing slice of values for CreateAlertingPolicyRequest fields according to their type
type CreateAlertingPolicyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreateAlertingPolicyRequest_FieldPath
}

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

func MustParseCreateAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) CreateAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseCreateAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreateAlertingPolicyRequest_FieldTerminalPathArrayOfValues struct {
	CreateAlertingPolicyRequest_FieldTerminalPath
	values interface{}
}

var _ CreateAlertingPolicyRequest_FieldPathArrayOfValues = (*CreateAlertingPolicyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreateAlertingPolicyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreateAlertingPolicyRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*alerting_policy.ParentReference) {
			values = append(values, v)
		}
	case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreateAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*alerting_policy.ParentReference, bool) {
	res, ok := fpaov.values.([]*alerting_policy.ParentReference)
	return res, ok
}
func (fpaov *CreateAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsAlertingPolicyArrayOfValues() ([]*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy)
	return res, ok
}

type CreateAlertingPolicyRequest_FieldSubPathArrayOfValues struct {
	CreateAlertingPolicyRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreateAlertingPolicyRequest_FieldPathArrayOfValues = (*CreateAlertingPolicyRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *CreateAlertingPolicyRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *CreateAlertingPolicyRequest_FieldSubPathArrayOfValues) AsAlertingPolicyPathArrayOfValues() (alerting_policy.AlertingPolicy_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(alerting_policy.AlertingPolicy_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateAlertingPolicyRequest_FieldPathSelector int32

const (
	UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy UpdateAlertingPolicyRequest_FieldPathSelector = 0
	UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask     UpdateAlertingPolicyRequest_FieldPathSelector = 1
	UpdateAlertingPolicyRequest_FieldPathSelectorCas            UpdateAlertingPolicyRequest_FieldPathSelector = 2
)

func (s UpdateAlertingPolicyRequest_FieldPathSelector) String() string {
	switch s {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return "alerting_policy"
	case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
		return "update_mask"
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		return "cas"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", s))
	}
}

func BuildUpdateAlertingPolicyRequest_FieldPath(fp gotenobject.RawFieldPath) (UpdateAlertingPolicyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateAlertingPolicyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "alerting_policy", "alertingPolicy", "alerting-policy":
			return &UpdateAlertingPolicyRequest_FieldTerminalPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy}, nil
		case "update_mask", "updateMask", "update-mask":
			return &UpdateAlertingPolicyRequest_FieldTerminalPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask}, nil
		case "cas":
			return &UpdateAlertingPolicyRequest_FieldTerminalPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorCas}, nil
		}
	} else {
		switch fp[0] {
		case "alerting_policy", "alertingPolicy", "alerting-policy":
			if subpath, err := alerting_policy.BuildAlertingPolicy_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateAlertingPolicyRequest_FieldSubPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy, subPath: subpath}, nil
			}
		case "cas":
			if subpath, err := BuildUpdateAlertingPolicyRequestCAS_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateAlertingPolicyRequest_FieldSubPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorCas, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateAlertingPolicyRequest", fp)
}

func ParseUpdateAlertingPolicyRequest_FieldPath(rawField string) (UpdateAlertingPolicyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateAlertingPolicyRequest_FieldPath(fp)
}

func MustParseUpdateAlertingPolicyRequest_FieldPath(rawField string) UpdateAlertingPolicyRequest_FieldPath {
	fp, err := ParseUpdateAlertingPolicyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateAlertingPolicyRequest_FieldTerminalPath struct {
	selector UpdateAlertingPolicyRequest_FieldPathSelector
}

var _ UpdateAlertingPolicyRequest_FieldPath = (*UpdateAlertingPolicyRequest_FieldTerminalPath)(nil)

func (fp *UpdateAlertingPolicyRequest_FieldTerminalPath) Selector() UpdateAlertingPolicyRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source UpdateAlertingPolicyRequest
func (fp *UpdateAlertingPolicyRequest_FieldTerminalPath) Get(source *UpdateAlertingPolicyRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
			if source.AlertingPolicy != nil {
				values = append(values, source.AlertingPolicy)
			}
		case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
			if source.UpdateMask != nil {
				values = append(values, source.UpdateMask)
			}
		case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
			if source.Cas != nil {
				values = append(values, source.Cas)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source UpdateAlertingPolicyRequest
func (fp *UpdateAlertingPolicyRequest_FieldTerminalPath) GetSingle(source *UpdateAlertingPolicyRequest) (interface{}, bool) {
	switch fp.selector {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		res := source.GetAlertingPolicy()
		return res, res != nil
	case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
		res := source.GetUpdateMask()
		return res, res != nil
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		res := source.GetCas()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *UpdateAlertingPolicyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return (*alerting_policy.AlertingPolicy)(nil)
	case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
		return (*alerting_policy.AlertingPolicy_FieldMask)(nil)
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		return (*UpdateAlertingPolicyRequest_CAS)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fp.selector))
	}
}

func (fp *UpdateAlertingPolicyRequest_FieldTerminalPath) ClearValue(item *UpdateAlertingPolicyRequest) {
	if item != nil {
		switch fp.selector {
		case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
			item.AlertingPolicy = nil
		case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
			item.UpdateMask = nil
		case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
			item.Cas = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fp.selector))
		}
	}
}

func (fp *UpdateAlertingPolicyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateAlertingPolicyRequest))
}

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

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

func (fp *UpdateAlertingPolicyRequest_FieldTerminalPath) WithIValue(value interface{}) UpdateAlertingPolicyRequest_FieldPathValue {
	switch fp.selector {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return &UpdateAlertingPolicyRequest_FieldTerminalPathValue{UpdateAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy)}
	case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
		return &UpdateAlertingPolicyRequest_FieldTerminalPathValue{UpdateAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy_FieldMask)}
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		return &UpdateAlertingPolicyRequest_FieldTerminalPathValue{UpdateAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*UpdateAlertingPolicyRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fp.selector))
	}
}

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

func (fp *UpdateAlertingPolicyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov := &UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues{UpdateAlertingPolicyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return &UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues{UpdateAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy)}
	case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
		return &UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues{UpdateAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy_FieldMask)}
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		return &UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues{UpdateAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*UpdateAlertingPolicyRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateAlertingPolicyRequest_FieldSubPath struct {
	selector UpdateAlertingPolicyRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateAlertingPolicyRequest_FieldPath = (*UpdateAlertingPolicyRequest_FieldSubPath)(nil)

func (fps *UpdateAlertingPolicyRequest_FieldSubPath) Selector() UpdateAlertingPolicyRequest_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateAlertingPolicyRequest_FieldSubPath) AsAlertingPolicySubPath() (alerting_policy.AlertingPolicy_FieldPath, bool) {
	res, ok := fps.subPath.(alerting_policy.AlertingPolicy_FieldPath)
	return res, ok
}
func (fps *UpdateAlertingPolicyRequest_FieldSubPath) AsCasSubPath() (UpdateAlertingPolicyRequestCAS_FieldPath, bool) {
	res, ok := fps.subPath.(UpdateAlertingPolicyRequestCAS_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source UpdateAlertingPolicyRequest
func (fps *UpdateAlertingPolicyRequest_FieldSubPath) Get(source *UpdateAlertingPolicyRequest) (values []interface{}) {
	if asAlertingPolicyFieldPath, ok := fps.AsAlertingPolicySubPath(); ok {
		values = append(values, asAlertingPolicyFieldPath.Get(source.GetAlertingPolicy())...)
	} else if asCASFieldPath, ok := fps.AsCasSubPath(); ok {
		values = append(values, asCASFieldPath.Get(source.GetCas())...)
	} else {
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fps.selector))
	}
	return
}

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

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

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

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

func (fps *UpdateAlertingPolicyRequest_FieldSubPath) ClearValue(item *UpdateAlertingPolicyRequest) {
	if item != nil {
		switch fps.selector {
		case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
			fps.subPath.ClearValueRaw(item.AlertingPolicy)
		case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
			fps.subPath.ClearValueRaw(item.Cas)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fps.selector))
		}
	}
}

func (fps *UpdateAlertingPolicyRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateAlertingPolicyRequest))
}

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

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

func (fps *UpdateAlertingPolicyRequest_FieldSubPath) WithIValue(value interface{}) UpdateAlertingPolicyRequest_FieldPathValue {
	return &UpdateAlertingPolicyRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateAlertingPolicyRequest_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateAlertingPolicyRequest_FieldPathArrayOfValues {
	return &UpdateAlertingPolicyRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateAlertingPolicyRequest_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateAlertingPolicyRequest_FieldPathArrayItemValue {
	return &UpdateAlertingPolicyRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseUpdateAlertingPolicyRequest_FieldPathValue(pathStr, valueStr string) UpdateAlertingPolicyRequest_FieldPathValue {
	fpv, err := ParseUpdateAlertingPolicyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateAlertingPolicyRequest_FieldTerminalPathValue struct {
	UpdateAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateAlertingPolicyRequest_FieldPathValue = (*UpdateAlertingPolicyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'UpdateAlertingPolicyRequest' as interface{}
func (fpv *UpdateAlertingPolicyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateAlertingPolicyRequest_FieldTerminalPathValue) AsAlertingPolicyValue() (*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy)
	return res, ok
}
func (fpv *UpdateAlertingPolicyRequest_FieldTerminalPathValue) AsUpdateMaskValue() (*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpv *UpdateAlertingPolicyRequest_FieldTerminalPathValue) AsCasValue() (*UpdateAlertingPolicyRequest_CAS, bool) {
	res, ok := fpv.value.(*UpdateAlertingPolicyRequest_CAS)
	return res, ok
}

// SetTo stores value for selected field for object UpdateAlertingPolicyRequest
func (fpv *UpdateAlertingPolicyRequest_FieldTerminalPathValue) SetTo(target **UpdateAlertingPolicyRequest) {
	if *target == nil {
		*target = new(UpdateAlertingPolicyRequest)
	}
	switch fpv.selector {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		(*target).AlertingPolicy = fpv.value.(*alerting_policy.AlertingPolicy)
	case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
		(*target).UpdateMask = fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		(*target).Cas = fpv.value.(*UpdateAlertingPolicyRequest_CAS)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fpv.selector))
	}
}

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

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

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

type UpdateAlertingPolicyRequest_FieldSubPathValue struct {
	UpdateAlertingPolicyRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateAlertingPolicyRequest_FieldPathValue = (*UpdateAlertingPolicyRequest_FieldSubPathValue)(nil)

func (fpvs *UpdateAlertingPolicyRequest_FieldSubPathValue) AsAlertingPolicyPathValue() (alerting_policy.AlertingPolicy_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue)
	return res, ok
}
func (fpvs *UpdateAlertingPolicyRequest_FieldSubPathValue) AsCasPathValue() (UpdateAlertingPolicyRequestCAS_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(UpdateAlertingPolicyRequestCAS_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateAlertingPolicyRequest_FieldSubPathValue) SetTo(target **UpdateAlertingPolicyRequest) {
	if *target == nil {
		*target = new(UpdateAlertingPolicyRequest)
	}
	switch fpvs.Selector() {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue).SetTo(&(*target).AlertingPolicy)
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		fpvs.subPathValue.(UpdateAlertingPolicyRequestCAS_FieldPathValue).SetTo(&(*target).Cas)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateAlertingPolicyRequest_FieldSubPathValue) CompareWith(source *UpdateAlertingPolicyRequest) (int, bool) {
	switch fpvs.Selector() {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue).CompareWith(source.GetAlertingPolicy())
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		return fpvs.subPathValue.(UpdateAlertingPolicyRequestCAS_FieldPathValue).CompareWith(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseUpdateAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr string) UpdateAlertingPolicyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateAlertingPolicyRequest_FieldTerminalPathArrayItemValue struct {
	UpdateAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateAlertingPolicyRequest_FieldPathArrayItemValue = (*UpdateAlertingPolicyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateAlertingPolicyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateAlertingPolicyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *UpdateAlertingPolicyRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdateAlertingPolicyRequest_FieldSubPathArrayItemValue) AsAlertingPolicyPathItemValue() (alerting_policy.AlertingPolicy_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(alerting_policy.AlertingPolicy_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *UpdateAlertingPolicyRequest_FieldSubPathArrayItemValue) AsCasPathItemValue() (UpdateAlertingPolicyRequestCAS_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(UpdateAlertingPolicyRequestCAS_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'UpdateAlertingPolicyRequest'
func (fpaivs *UpdateAlertingPolicyRequest_FieldSubPathArrayItemValue) ContainsValue(source *UpdateAlertingPolicyRequest) bool {
	switch fpaivs.Selector() {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		return fpaivs.subPathItemValue.(alerting_policy.AlertingPolicy_FieldPathArrayItemValue).ContainsValue(source.GetAlertingPolicy())
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		return fpaivs.subPathItemValue.(UpdateAlertingPolicyRequestCAS_FieldPathArrayItemValue).ContainsValue(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest: %d", fpaivs.Selector()))
	}
}

// UpdateAlertingPolicyRequest_FieldPathArrayOfValues allows storing slice of values for UpdateAlertingPolicyRequest fields according to their type
type UpdateAlertingPolicyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdateAlertingPolicyRequest_FieldPath
}

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

func MustParseUpdateAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues struct {
	UpdateAlertingPolicyRequest_FieldTerminalPath
	values interface{}
}

var _ UpdateAlertingPolicyRequest_FieldPathArrayOfValues = (*UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy) {
			values = append(values, v)
		}
	case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask) {
			values = append(values, v)
		}
	case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
		for _, v := range fpaov.values.([]*UpdateAlertingPolicyRequest_CAS) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsAlertingPolicyArrayOfValues() ([]*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy)
	return res, ok
}
func (fpaov *UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsUpdateMaskArrayOfValues() ([]*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}
func (fpaov *UpdateAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsCasArrayOfValues() ([]*UpdateAlertingPolicyRequest_CAS, bool) {
	res, ok := fpaov.values.([]*UpdateAlertingPolicyRequest_CAS)
	return res, ok
}

type UpdateAlertingPolicyRequest_FieldSubPathArrayOfValues struct {
	UpdateAlertingPolicyRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateAlertingPolicyRequest_FieldPathArrayOfValues = (*UpdateAlertingPolicyRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateAlertingPolicyRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateAlertingPolicyRequest_FieldSubPathArrayOfValues) AsAlertingPolicyPathArrayOfValues() (alerting_policy.AlertingPolicy_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(alerting_policy.AlertingPolicy_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *UpdateAlertingPolicyRequest_FieldSubPathArrayOfValues) AsCasPathArrayOfValues() (UpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(UpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateAlertingPolicyRequestCAS_FieldPathSelector int32

const (
	UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState UpdateAlertingPolicyRequestCAS_FieldPathSelector = 0
	UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask        UpdateAlertingPolicyRequestCAS_FieldPathSelector = 1
)

func (s UpdateAlertingPolicyRequestCAS_FieldPathSelector) String() string {
	switch s {
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
		return "conditional_state"
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask:
		return "field_mask"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", s))
	}
}

func BuildUpdateAlertingPolicyRequestCAS_FieldPath(fp gotenobject.RawFieldPath) (UpdateAlertingPolicyRequestCAS_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateAlertingPolicyRequest_CAS")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			return &UpdateAlertingPolicyRequestCAS_FieldTerminalPath{selector: UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &UpdateAlertingPolicyRequestCAS_FieldTerminalPath{selector: UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask}, nil
		}
	} else {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			if subpath, err := alerting_policy.BuildAlertingPolicy_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateAlertingPolicyRequestCAS_FieldSubPath{selector: UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateAlertingPolicyRequest_CAS", fp)
}

func ParseUpdateAlertingPolicyRequestCAS_FieldPath(rawField string) (UpdateAlertingPolicyRequestCAS_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateAlertingPolicyRequestCAS_FieldPath(fp)
}

func MustParseUpdateAlertingPolicyRequestCAS_FieldPath(rawField string) UpdateAlertingPolicyRequestCAS_FieldPath {
	fp, err := ParseUpdateAlertingPolicyRequestCAS_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateAlertingPolicyRequestCAS_FieldTerminalPath struct {
	selector UpdateAlertingPolicyRequestCAS_FieldPathSelector
}

var _ UpdateAlertingPolicyRequestCAS_FieldPath = (*UpdateAlertingPolicyRequestCAS_FieldTerminalPath)(nil)

func (fp *UpdateAlertingPolicyRequestCAS_FieldTerminalPath) Selector() UpdateAlertingPolicyRequestCAS_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *UpdateAlertingPolicyRequestCAS_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
		return (*alerting_policy.AlertingPolicy)(nil)
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask:
		return (*alerting_policy.AlertingPolicy_FieldMask)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdateAlertingPolicyRequestCAS_FieldTerminalPath) ClearValue(item *UpdateAlertingPolicyRequest_CAS) {
	if item != nil {
		switch fp.selector {
		case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
			item.ConditionalState = nil
		case UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fp.selector))
		}
	}
}

func (fp *UpdateAlertingPolicyRequestCAS_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateAlertingPolicyRequest_CAS))
}

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

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

func (fp *UpdateAlertingPolicyRequestCAS_FieldTerminalPath) WithIValue(value interface{}) UpdateAlertingPolicyRequestCAS_FieldPathValue {
	switch fp.selector {
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateAlertingPolicyRequestCAS_FieldTerminalPathValue{UpdateAlertingPolicyRequestCAS_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy)}
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateAlertingPolicyRequestCAS_FieldTerminalPathValue{UpdateAlertingPolicyRequestCAS_FieldTerminalPath: *fp, value: value.(*alerting_policy.AlertingPolicy_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fp.selector))
	}
}

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

func (fp *UpdateAlertingPolicyRequestCAS_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues {
	fpaov := &UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayOfValues{UpdateAlertingPolicyRequestCAS_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayOfValues{UpdateAlertingPolicyRequestCAS_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy)}
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayOfValues{UpdateAlertingPolicyRequestCAS_FieldTerminalPath: *fp, values: values.([]*alerting_policy.AlertingPolicy_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateAlertingPolicyRequestCAS_FieldSubPath struct {
	selector UpdateAlertingPolicyRequestCAS_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateAlertingPolicyRequestCAS_FieldPath = (*UpdateAlertingPolicyRequestCAS_FieldSubPath)(nil)

func (fps *UpdateAlertingPolicyRequestCAS_FieldSubPath) Selector() UpdateAlertingPolicyRequestCAS_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateAlertingPolicyRequestCAS_FieldSubPath) AsConditionalStateSubPath() (alerting_policy.AlertingPolicy_FieldPath, bool) {
	res, ok := fps.subPath.(alerting_policy.AlertingPolicy_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source UpdateAlertingPolicyRequest_CAS
func (fps *UpdateAlertingPolicyRequestCAS_FieldSubPath) Get(source *UpdateAlertingPolicyRequest_CAS) (values []interface{}) {
	if asAlertingPolicyFieldPath, ok := fps.AsConditionalStateSubPath(); ok {
		values = append(values, asAlertingPolicyFieldPath.Get(source.GetConditionalState())...)
	} else {
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fps.selector))
	}
	return
}

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

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

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

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

func (fps *UpdateAlertingPolicyRequestCAS_FieldSubPath) ClearValue(item *UpdateAlertingPolicyRequest_CAS) {
	if item != nil {
		switch fps.selector {
		case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
			fps.subPath.ClearValueRaw(item.ConditionalState)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fps.selector))
		}
	}
}

func (fps *UpdateAlertingPolicyRequestCAS_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateAlertingPolicyRequest_CAS))
}

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

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

func (fps *UpdateAlertingPolicyRequestCAS_FieldSubPath) WithIValue(value interface{}) UpdateAlertingPolicyRequestCAS_FieldPathValue {
	return &UpdateAlertingPolicyRequestCAS_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateAlertingPolicyRequestCAS_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues {
	return &UpdateAlertingPolicyRequestCAS_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateAlertingPolicyRequestCAS_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateAlertingPolicyRequestCAS_FieldPathArrayItemValue {
	return &UpdateAlertingPolicyRequestCAS_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// UpdateAlertingPolicyRequestCAS_FieldPathValue allows storing values for CAS fields according to their type
type UpdateAlertingPolicyRequestCAS_FieldPathValue interface {
	UpdateAlertingPolicyRequestCAS_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **UpdateAlertingPolicyRequest_CAS)
	CompareWith(*UpdateAlertingPolicyRequest_CAS) (cmp int, comparable bool)
}

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

func MustParseUpdateAlertingPolicyRequestCAS_FieldPathValue(pathStr, valueStr string) UpdateAlertingPolicyRequestCAS_FieldPathValue {
	fpv, err := ParseUpdateAlertingPolicyRequestCAS_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateAlertingPolicyRequestCAS_FieldTerminalPathValue struct {
	UpdateAlertingPolicyRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateAlertingPolicyRequestCAS_FieldPathValue = (*UpdateAlertingPolicyRequestCAS_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CAS' as interface{}
func (fpv *UpdateAlertingPolicyRequestCAS_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateAlertingPolicyRequestCAS_FieldTerminalPathValue) AsConditionalStateValue() (*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy)
	return res, ok
}
func (fpv *UpdateAlertingPolicyRequestCAS_FieldTerminalPathValue) AsFieldMaskValue() (*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}

// SetTo stores value for selected field for object CAS
func (fpv *UpdateAlertingPolicyRequestCAS_FieldTerminalPathValue) SetTo(target **UpdateAlertingPolicyRequest_CAS) {
	if *target == nil {
		*target = new(UpdateAlertingPolicyRequest_CAS)
	}
	switch fpv.selector {
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
		(*target).ConditionalState = fpv.value.(*alerting_policy.AlertingPolicy)
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*alerting_policy.AlertingPolicy_FieldMask)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fpv.selector))
	}
}

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

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

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

type UpdateAlertingPolicyRequestCAS_FieldSubPathValue struct {
	UpdateAlertingPolicyRequestCAS_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateAlertingPolicyRequestCAS_FieldPathValue = (*UpdateAlertingPolicyRequestCAS_FieldSubPathValue)(nil)

func (fpvs *UpdateAlertingPolicyRequestCAS_FieldSubPathValue) AsConditionalStatePathValue() (alerting_policy.AlertingPolicy_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateAlertingPolicyRequestCAS_FieldSubPathValue) SetTo(target **UpdateAlertingPolicyRequest_CAS) {
	if *target == nil {
		*target = new(UpdateAlertingPolicyRequest_CAS)
	}
	switch fpvs.Selector() {
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
		fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue).SetTo(&(*target).ConditionalState)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateAlertingPolicyRequestCAS_FieldSubPathValue) CompareWith(source *UpdateAlertingPolicyRequest_CAS) (int, bool) {
	switch fpvs.Selector() {
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
		return fpvs.subPathValue.(alerting_policy.AlertingPolicy_FieldPathValue).CompareWith(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseUpdateAlertingPolicyRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) UpdateAlertingPolicyRequestCAS_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateAlertingPolicyRequestCAS_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayItemValue struct {
	UpdateAlertingPolicyRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateAlertingPolicyRequestCAS_FieldPathArrayItemValue = (*UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateAlertingPolicyRequest_CAS) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'CAS'
func (fpaiv *UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayItemValue) ContainsValue(source *UpdateAlertingPolicyRequest_CAS) bool {
	slice := fpaiv.UpdateAlertingPolicyRequestCAS_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 UpdateAlertingPolicyRequestCAS_FieldSubPathArrayItemValue struct {
	UpdateAlertingPolicyRequestCAS_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *UpdateAlertingPolicyRequestCAS_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdateAlertingPolicyRequestCAS_FieldSubPathArrayItemValue) AsConditionalStatePathItemValue() (alerting_policy.AlertingPolicy_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(alerting_policy.AlertingPolicy_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'CAS'
func (fpaivs *UpdateAlertingPolicyRequestCAS_FieldSubPathArrayItemValue) ContainsValue(source *UpdateAlertingPolicyRequest_CAS) bool {
	switch fpaivs.Selector() {
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
		return fpaivs.subPathItemValue.(alerting_policy.AlertingPolicy_FieldPathArrayItemValue).ContainsValue(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateAlertingPolicyRequest_CAS: %d", fpaivs.Selector()))
	}
}

// UpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues allows storing slice of values for CAS fields according to their type
type UpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdateAlertingPolicyRequestCAS_FieldPath
}

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

func MustParseUpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayOfValues struct {
	UpdateAlertingPolicyRequestCAS_FieldTerminalPath
	values interface{}
}

var _ UpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues = (*UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy) {
			values = append(values, v)
		}
	case UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayOfValues) AsConditionalStateArrayOfValues() ([]*alerting_policy.AlertingPolicy, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy)
	return res, ok
}
func (fpaov *UpdateAlertingPolicyRequestCAS_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*alerting_policy.AlertingPolicy_FieldMask, bool) {
	res, ok := fpaov.values.([]*alerting_policy.AlertingPolicy_FieldMask)
	return res, ok
}

type UpdateAlertingPolicyRequestCAS_FieldSubPathArrayOfValues struct {
	UpdateAlertingPolicyRequestCAS_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateAlertingPolicyRequestCAS_FieldPathArrayOfValues = (*UpdateAlertingPolicyRequestCAS_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateAlertingPolicyRequestCAS_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateAlertingPolicyRequestCAS_FieldSubPathArrayOfValues) AsConditionalStatePathArrayOfValues() (alerting_policy.AlertingPolicy_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(alerting_policy.AlertingPolicy_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeleteAlertingPolicyRequest_FieldPathSelector int32

const (
	DeleteAlertingPolicyRequest_FieldPathSelectorName DeleteAlertingPolicyRequest_FieldPathSelector = 0
)

func (s DeleteAlertingPolicyRequest_FieldPathSelector) String() string {
	switch s {
	case DeleteAlertingPolicyRequest_FieldPathSelectorName:
		return "name"
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteAlertingPolicyRequest: %d", s))
	}
}

func BuildDeleteAlertingPolicyRequest_FieldPath(fp gotenobject.RawFieldPath) (DeleteAlertingPolicyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object DeleteAlertingPolicyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &DeleteAlertingPolicyRequest_FieldTerminalPath{selector: DeleteAlertingPolicyRequest_FieldPathSelectorName}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object DeleteAlertingPolicyRequest", fp)
}

func ParseDeleteAlertingPolicyRequest_FieldPath(rawField string) (DeleteAlertingPolicyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeleteAlertingPolicyRequest_FieldPath(fp)
}

func MustParseDeleteAlertingPolicyRequest_FieldPath(rawField string) DeleteAlertingPolicyRequest_FieldPath {
	fp, err := ParseDeleteAlertingPolicyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeleteAlertingPolicyRequest_FieldTerminalPath struct {
	selector DeleteAlertingPolicyRequest_FieldPathSelector
}

var _ DeleteAlertingPolicyRequest_FieldPath = (*DeleteAlertingPolicyRequest_FieldTerminalPath)(nil)

func (fp *DeleteAlertingPolicyRequest_FieldTerminalPath) Selector() DeleteAlertingPolicyRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *DeleteAlertingPolicyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeleteAlertingPolicyRequest_FieldPathSelectorName:
		return (*alerting_policy.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteAlertingPolicyRequest: %d", fp.selector))
	}
}

func (fp *DeleteAlertingPolicyRequest_FieldTerminalPath) ClearValue(item *DeleteAlertingPolicyRequest) {
	if item != nil {
		switch fp.selector {
		case DeleteAlertingPolicyRequest_FieldPathSelectorName:
			item.Name = nil
		default:
			panic(fmt.Sprintf("Invalid selector for DeleteAlertingPolicyRequest: %d", fp.selector))
		}
	}
}

func (fp *DeleteAlertingPolicyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*DeleteAlertingPolicyRequest))
}

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

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

func (fp *DeleteAlertingPolicyRequest_FieldTerminalPath) WithIValue(value interface{}) DeleteAlertingPolicyRequest_FieldPathValue {
	switch fp.selector {
	case DeleteAlertingPolicyRequest_FieldPathSelectorName:
		return &DeleteAlertingPolicyRequest_FieldTerminalPathValue{DeleteAlertingPolicyRequest_FieldTerminalPath: *fp, value: value.(*alerting_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteAlertingPolicyRequest: %d", fp.selector))
	}
}

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

func (fp *DeleteAlertingPolicyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeleteAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov := &DeleteAlertingPolicyRequest_FieldTerminalPathArrayOfValues{DeleteAlertingPolicyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeleteAlertingPolicyRequest_FieldPathSelectorName:
		return &DeleteAlertingPolicyRequest_FieldTerminalPathArrayOfValues{DeleteAlertingPolicyRequest_FieldTerminalPath: *fp, values: values.([]*alerting_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteAlertingPolicyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseDeleteAlertingPolicyRequest_FieldPathValue(pathStr, valueStr string) DeleteAlertingPolicyRequest_FieldPathValue {
	fpv, err := ParseDeleteAlertingPolicyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeleteAlertingPolicyRequest_FieldTerminalPathValue struct {
	DeleteAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteAlertingPolicyRequest_FieldPathValue = (*DeleteAlertingPolicyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'DeleteAlertingPolicyRequest' as interface{}
func (fpv *DeleteAlertingPolicyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeleteAlertingPolicyRequest_FieldTerminalPathValue) AsNameValue() (*alerting_policy.Reference, bool) {
	res, ok := fpv.value.(*alerting_policy.Reference)
	return res, ok
}

// SetTo stores value for selected field for object DeleteAlertingPolicyRequest
func (fpv *DeleteAlertingPolicyRequest_FieldTerminalPathValue) SetTo(target **DeleteAlertingPolicyRequest) {
	if *target == nil {
		*target = new(DeleteAlertingPolicyRequest)
	}
	switch fpv.selector {
	case DeleteAlertingPolicyRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*alerting_policy.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteAlertingPolicyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeleteAlertingPolicyRequest_FieldTerminalPathValue' with the value under path in 'DeleteAlertingPolicyRequest'.
func (fpv *DeleteAlertingPolicyRequest_FieldTerminalPathValue) CompareWith(source *DeleteAlertingPolicyRequest) (int, bool) {
	switch fpv.selector {
	case DeleteAlertingPolicyRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*alerting_policy.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteAlertingPolicyRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeleteAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr string) DeleteAlertingPolicyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseDeleteAlertingPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeleteAlertingPolicyRequest_FieldTerminalPathArrayItemValue struct {
	DeleteAlertingPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteAlertingPolicyRequest_FieldPathArrayItemValue = (*DeleteAlertingPolicyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeleteAlertingPolicyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *DeleteAlertingPolicyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// DeleteAlertingPolicyRequest_FieldPathArrayOfValues allows storing slice of values for DeleteAlertingPolicyRequest fields according to their type
type DeleteAlertingPolicyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeleteAlertingPolicyRequest_FieldPath
}

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

func MustParseDeleteAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) DeleteAlertingPolicyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseDeleteAlertingPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeleteAlertingPolicyRequest_FieldTerminalPathArrayOfValues struct {
	DeleteAlertingPolicyRequest_FieldTerminalPath
	values interface{}
}

var _ DeleteAlertingPolicyRequest_FieldPathArrayOfValues = (*DeleteAlertingPolicyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeleteAlertingPolicyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeleteAlertingPolicyRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*alerting_policy.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeleteAlertingPolicyRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*alerting_policy.Reference, bool) {
	res, ok := fpaov.values.([]*alerting_policy.Reference)
	return res, ok
}