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

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

package alert

import (
	"encoding/json"
	"strings"

	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/proto"
	preflect "google.golang.org/protobuf/reflect/protoreflect"
	googlefieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"

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

// proto imports
import (
	alerting_condition "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alerting_condition"
	common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/common"
	meta "github.com/cloudwan/goten-sdk/types/meta"
)

// ensure the imports are used
var (
	_ = new(json.Marshaler)
	_ = strings.Builder{}

	_ = codes.NotFound
	_ = status.Status{}
	_ = new(proto.Message)
	_ = new(preflect.Message)
	_ = googlefieldmaskpb.FieldMask{}

	_ = new(gotenobject.FieldMask)
)

// make sure we're using proto imports
var (
	_ = &alerting_condition.AlertingCondition{}
	_ = &common.LabelDescriptor{}
	_ = &meta.Meta{}
)

type Alert_FieldMask struct {
	Paths []Alert_FieldPath
}

func FullAlert_FieldMask() *Alert_FieldMask {
	res := &Alert_FieldMask{}
	res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorName})
	res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorMetadata})
	res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorDisplayName})
	res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorInfo})
	res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorState})
	return res
}

func (fieldMask *Alert_FieldMask) String() string {
	if fieldMask == nil {
		return "<nil>"
	}
	pathsStr := make([]string, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		pathsStr = append(pathsStr, path.String())
	}
	return strings.Join(pathsStr, ", ")
}

func (fieldMask *Alert_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 5)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*Alert_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

func (fieldMask *Alert_FieldMask) ProtoReflect() preflect.Message {
	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
		return ParseAlert_FieldPath(raw)
	})
}

func (fieldMask *Alert_FieldMask) ProtoMessage() {}

func (fieldMask *Alert_FieldMask) Reset() {
	if fieldMask != nil {
		fieldMask.Paths = nil
	}
}

func (fieldMask *Alert_FieldMask) Subtract(other *Alert_FieldMask) *Alert_FieldMask {
	result := &Alert_FieldMask{}
	removedSelectors := make([]bool, 5)
	otherSubMasks := map[Alert_FieldPathSelector]gotenobject.FieldMask{
		Alert_FieldPathSelectorMetadata: &meta.Meta_FieldMask{},
		Alert_FieldPathSelectorInfo:     &Alert_Info_FieldMask{},
		Alert_FieldPathSelectorState:    &Alert_State_FieldMask{},
	}
	mySubMasks := map[Alert_FieldPathSelector]gotenobject.FieldMask{
		Alert_FieldPathSelectorMetadata: &meta.Meta_FieldMask{},
		Alert_FieldPathSelectorInfo:     &Alert_Info_FieldMask{},
		Alert_FieldPathSelectorState:    &Alert_State_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *Alert_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *Alert_FieldSubPath:
			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
		}
	}
	for _, path := range fieldMask.GetPaths() {
		if !removedSelectors[int(path.Selector())] {
			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
				if tp, ok := path.(*Alert_FieldTerminalPath); ok {
					switch tp.selector {
					case Alert_FieldPathSelectorMetadata:
						mySubMasks[Alert_FieldPathSelectorMetadata] = meta.FullMeta_FieldMask()
					case Alert_FieldPathSelectorInfo:
						mySubMasks[Alert_FieldPathSelectorInfo] = FullAlert_Info_FieldMask()
					case Alert_FieldPathSelectorState:
						mySubMasks[Alert_FieldPathSelectorState] = FullAlert_State_FieldMask()
					}
				} else if tp, ok := path.(*Alert_FieldSubPath); ok {
					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
				}
			} else {
				result.Paths = append(result.Paths, path)
			}
		}
	}
	for selector, mySubMask := range mySubMasks {
		if mySubMask.PathsCount() > 0 {
			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
				result.Paths = append(result.Paths, &Alert_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

	if len(result.Paths) == 0 {
		return nil
	}
	return result
}

func (fieldMask *Alert_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*Alert_FieldMask))
}

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *Alert_FieldMask) FilterInputFields() *Alert_FieldMask {
	result := &Alert_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case Alert_FieldPathSelectorMetadata:
			if _, ok := path.(*Alert_FieldTerminalPath); ok {
				for _, subpath := range meta.FullMeta_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &Alert_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*Alert_FieldSubPath); ok {
				selectedMask := &meta.Meta_FieldMask{
					Paths: []meta.Meta_FieldPath{sub.subPath.(meta.Meta_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &Alert_FieldSubPath{selector: Alert_FieldPathSelectorMetadata, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

// ToFieldMask is used for proto conversions
func (fieldMask *Alert_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	for _, path := range fieldMask.Paths {
		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
	}
	return protoFieldMask
}

func (fieldMask *Alert_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
	if fieldMask == nil {
		return status.Error(codes.Internal, "target field mask is nil")
	}
	fieldMask.Paths = make([]Alert_FieldPath, 0, len(protoFieldMask.Paths))
	for _, strPath := range protoFieldMask.Paths {
		path, err := ParseAlert_FieldPath(strPath)
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, path)
	}
	return nil
}

// implement methods required by customType
func (fieldMask Alert_FieldMask) Marshal() ([]byte, error) {
	protoFieldMask := fieldMask.ToProtoFieldMask()
	return proto.Marshal(protoFieldMask)
}

func (fieldMask *Alert_FieldMask) Unmarshal(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

func (fieldMask Alert_FieldMask) MarshalJSON() ([]byte, error) {
	return json.Marshal(fieldMask.ToProtoFieldMask())
}

func (fieldMask *Alert_FieldMask) UnmarshalJSON(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := json.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_FieldMask) AppendPath(path Alert_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

func (fieldMask *Alert_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path.(Alert_FieldPath))
}

func (fieldMask *Alert_FieldMask) GetPaths() []Alert_FieldPath {
	if fieldMask == nil {
		return nil
	}
	return fieldMask.Paths
}

func (fieldMask *Alert_FieldMask) GetRawPaths() []gotenobject.FieldPath {
	if fieldMask == nil {
		return nil
	}
	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		rawPaths = append(rawPaths, path)
	}
	return rawPaths
}

func (fieldMask *Alert_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseAlert_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *Alert_FieldMask) Set(target, source *Alert) {
	for _, path := range fieldMask.Paths {
		val, _ := path.GetSingle(source)
		// if val is nil, then field does not exist in source, skip
		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
		if val != nil {
			path.WithIValue(val).SetTo(&target)
		}
	}
}

func (fieldMask *Alert_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*Alert), source.(*Alert))
}

func (fieldMask *Alert_FieldMask) Project(source *Alert) *Alert {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &Alert{}
	metadataMask := &meta.Meta_FieldMask{}
	wholeMetadataAccepted := false
	infoMask := &Alert_Info_FieldMask{}
	wholeInfoAccepted := false
	stateMask := &Alert_State_FieldMask{}
	wholeStateAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *Alert_FieldTerminalPath:
			switch tp.selector {
			case Alert_FieldPathSelectorName:
				result.Name = source.Name
			case Alert_FieldPathSelectorMetadata:
				result.Metadata = source.Metadata
				wholeMetadataAccepted = true
			case Alert_FieldPathSelectorDisplayName:
				result.DisplayName = source.DisplayName
			case Alert_FieldPathSelectorInfo:
				result.Info = source.Info
				wholeInfoAccepted = true
			case Alert_FieldPathSelectorState:
				result.State = source.State
				wholeStateAccepted = true
			}
		case *Alert_FieldSubPath:
			switch tp.selector {
			case Alert_FieldPathSelectorMetadata:
				metadataMask.AppendPath(tp.subPath.(meta.Meta_FieldPath))
			case Alert_FieldPathSelectorInfo:
				infoMask.AppendPath(tp.subPath.(AlertInfo_FieldPath))
			case Alert_FieldPathSelectorState:
				stateMask.AppendPath(tp.subPath.(AlertState_FieldPath))
			}
		}
	}
	if wholeMetadataAccepted == false && len(metadataMask.Paths) > 0 {
		result.Metadata = metadataMask.Project(source.GetMetadata())
	}
	if wholeInfoAccepted == false && len(infoMask.Paths) > 0 {
		result.Info = infoMask.Project(source.GetInfo())
	}
	if wholeStateAccepted == false && len(stateMask.Paths) > 0 {
		result.State = stateMask.Project(source.GetState())
	}
	return result
}

func (fieldMask *Alert_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*Alert))
}

func (fieldMask *Alert_FieldMask) PathsCount() int {
	if fieldMask == nil {
		return 0
	}
	return len(fieldMask.Paths)
}

type Alert_Info_FieldMask struct {
	Paths []AlertInfo_FieldPath
}

func FullAlert_Info_FieldMask() *Alert_Info_FieldMask {
	res := &Alert_Info_FieldMask{}
	res.Paths = append(res.Paths, &AlertInfo_FieldTerminalPath{selector: AlertInfo_FieldPathSelectorTimeSerie})
	res.Paths = append(res.Paths, &AlertInfo_FieldTerminalPath{selector: AlertInfo_FieldPathSelectorObservedValues})
	return res
}

func (fieldMask *Alert_Info_FieldMask) String() string {
	if fieldMask == nil {
		return "<nil>"
	}
	pathsStr := make([]string, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		pathsStr = append(pathsStr, path.String())
	}
	return strings.Join(pathsStr, ", ")
}

func (fieldMask *Alert_Info_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 2)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*AlertInfo_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

func (fieldMask *Alert_Info_FieldMask) ProtoReflect() preflect.Message {
	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
		return ParseAlertInfo_FieldPath(raw)
	})
}

func (fieldMask *Alert_Info_FieldMask) ProtoMessage() {}

func (fieldMask *Alert_Info_FieldMask) Reset() {
	if fieldMask != nil {
		fieldMask.Paths = nil
	}
}

func (fieldMask *Alert_Info_FieldMask) Subtract(other *Alert_Info_FieldMask) *Alert_Info_FieldMask {
	result := &Alert_Info_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[AlertInfo_FieldPathSelector]gotenobject.FieldMask{
		AlertInfo_FieldPathSelectorTimeSerie:      &Alert_Info_TimeSerie_FieldMask{},
		AlertInfo_FieldPathSelectorObservedValues: &Alert_Info_ObservedValues_FieldMask{},
	}
	mySubMasks := map[AlertInfo_FieldPathSelector]gotenobject.FieldMask{
		AlertInfo_FieldPathSelectorTimeSerie:      &Alert_Info_TimeSerie_FieldMask{},
		AlertInfo_FieldPathSelectorObservedValues: &Alert_Info_ObservedValues_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *AlertInfo_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *AlertInfo_FieldSubPath:
			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
		}
	}
	for _, path := range fieldMask.GetPaths() {
		if !removedSelectors[int(path.Selector())] {
			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
				if tp, ok := path.(*AlertInfo_FieldTerminalPath); ok {
					switch tp.selector {
					case AlertInfo_FieldPathSelectorTimeSerie:
						mySubMasks[AlertInfo_FieldPathSelectorTimeSerie] = FullAlert_Info_TimeSerie_FieldMask()
					case AlertInfo_FieldPathSelectorObservedValues:
						mySubMasks[AlertInfo_FieldPathSelectorObservedValues] = FullAlert_Info_ObservedValues_FieldMask()
					}
				} else if tp, ok := path.(*AlertInfo_FieldSubPath); ok {
					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
				}
			} else {
				result.Paths = append(result.Paths, path)
			}
		}
	}
	for selector, mySubMask := range mySubMasks {
		if mySubMask.PathsCount() > 0 {
			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
				result.Paths = append(result.Paths, &AlertInfo_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

	if len(result.Paths) == 0 {
		return nil
	}
	return result
}

func (fieldMask *Alert_Info_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*Alert_Info_FieldMask))
}

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *Alert_Info_FieldMask) FilterInputFields() *Alert_Info_FieldMask {
	result := &Alert_Info_FieldMask{}
	result.Paths = append(result.Paths, fieldMask.Paths...)
	return result
}

// ToFieldMask is used for proto conversions
func (fieldMask *Alert_Info_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	for _, path := range fieldMask.Paths {
		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
	}
	return protoFieldMask
}

func (fieldMask *Alert_Info_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
	if fieldMask == nil {
		return status.Error(codes.Internal, "target field mask is nil")
	}
	fieldMask.Paths = make([]AlertInfo_FieldPath, 0, len(protoFieldMask.Paths))
	for _, strPath := range protoFieldMask.Paths {
		path, err := ParseAlertInfo_FieldPath(strPath)
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, path)
	}
	return nil
}

// implement methods required by customType
func (fieldMask Alert_Info_FieldMask) Marshal() ([]byte, error) {
	protoFieldMask := fieldMask.ToProtoFieldMask()
	return proto.Marshal(protoFieldMask)
}

func (fieldMask *Alert_Info_FieldMask) Unmarshal(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_Info_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

func (fieldMask Alert_Info_FieldMask) MarshalJSON() ([]byte, error) {
	return json.Marshal(fieldMask.ToProtoFieldMask())
}

func (fieldMask *Alert_Info_FieldMask) UnmarshalJSON(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := json.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_Info_FieldMask) AppendPath(path AlertInfo_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

func (fieldMask *Alert_Info_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path.(AlertInfo_FieldPath))
}

func (fieldMask *Alert_Info_FieldMask) GetPaths() []AlertInfo_FieldPath {
	if fieldMask == nil {
		return nil
	}
	return fieldMask.Paths
}

func (fieldMask *Alert_Info_FieldMask) GetRawPaths() []gotenobject.FieldPath {
	if fieldMask == nil {
		return nil
	}
	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		rawPaths = append(rawPaths, path)
	}
	return rawPaths
}

func (fieldMask *Alert_Info_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseAlertInfo_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *Alert_Info_FieldMask) Set(target, source *Alert_Info) {
	for _, path := range fieldMask.Paths {
		val, _ := path.GetSingle(source)
		// if val is nil, then field does not exist in source, skip
		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
		if val != nil {
			path.WithIValue(val).SetTo(&target)
		}
	}
}

func (fieldMask *Alert_Info_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*Alert_Info), source.(*Alert_Info))
}

func (fieldMask *Alert_Info_FieldMask) Project(source *Alert_Info) *Alert_Info {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &Alert_Info{}
	timeSerieMask := &Alert_Info_TimeSerie_FieldMask{}
	wholeTimeSerieAccepted := false
	observedValuesMask := &Alert_Info_ObservedValues_FieldMask{}
	wholeObservedValuesAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *AlertInfo_FieldTerminalPath:
			switch tp.selector {
			case AlertInfo_FieldPathSelectorTimeSerie:
				result.TimeSerie = source.TimeSerie
				wholeTimeSerieAccepted = true
			case AlertInfo_FieldPathSelectorObservedValues:
				result.ObservedValues = source.ObservedValues
				wholeObservedValuesAccepted = true
			}
		case *AlertInfo_FieldSubPath:
			switch tp.selector {
			case AlertInfo_FieldPathSelectorTimeSerie:
				timeSerieMask.AppendPath(tp.subPath.(AlertInfoTimeSerie_FieldPath))
			case AlertInfo_FieldPathSelectorObservedValues:
				observedValuesMask.AppendPath(tp.subPath.(AlertInfoObservedValues_FieldPath))
			}
		}
	}
	if wholeTimeSerieAccepted == false && len(timeSerieMask.Paths) > 0 {
		result.TimeSerie = timeSerieMask.Project(source.GetTimeSerie())
	}
	if wholeObservedValuesAccepted == false && len(observedValuesMask.Paths) > 0 {
		result.ObservedValues = observedValuesMask.Project(source.GetObservedValues())
	}
	return result
}

func (fieldMask *Alert_Info_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*Alert_Info))
}

func (fieldMask *Alert_Info_FieldMask) PathsCount() int {
	if fieldMask == nil {
		return 0
	}
	return len(fieldMask.Paths)
}

type Alert_State_FieldMask struct {
	Paths []AlertState_FieldPath
}

func FullAlert_State_FieldMask() *Alert_State_FieldMask {
	res := &Alert_State_FieldMask{}
	res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsFiring})
	res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsAcknowledged})
	res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsSilenced})
	res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorLifetime})
	res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNeedsNotification})
	res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNotificationCreated})
	res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorLifecycleCompleted})
	return res
}

func (fieldMask *Alert_State_FieldMask) String() string {
	if fieldMask == nil {
		return "<nil>"
	}
	pathsStr := make([]string, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		pathsStr = append(pathsStr, path.String())
	}
	return strings.Join(pathsStr, ", ")
}

func (fieldMask *Alert_State_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 7)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*AlertState_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

func (fieldMask *Alert_State_FieldMask) ProtoReflect() preflect.Message {
	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
		return ParseAlertState_FieldPath(raw)
	})
}

func (fieldMask *Alert_State_FieldMask) ProtoMessage() {}

func (fieldMask *Alert_State_FieldMask) Reset() {
	if fieldMask != nil {
		fieldMask.Paths = nil
	}
}

func (fieldMask *Alert_State_FieldMask) Subtract(other *Alert_State_FieldMask) *Alert_State_FieldMask {
	result := &Alert_State_FieldMask{}
	removedSelectors := make([]bool, 7)
	otherSubMasks := map[AlertState_FieldPathSelector]gotenobject.FieldMask{
		AlertState_FieldPathSelectorLifetime: &common.TimeRange_FieldMask{},
	}
	mySubMasks := map[AlertState_FieldPathSelector]gotenobject.FieldMask{
		AlertState_FieldPathSelectorLifetime: &common.TimeRange_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *AlertState_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *AlertState_FieldSubPath:
			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
		}
	}
	for _, path := range fieldMask.GetPaths() {
		if !removedSelectors[int(path.Selector())] {
			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
				if tp, ok := path.(*AlertState_FieldTerminalPath); ok {
					switch tp.selector {
					case AlertState_FieldPathSelectorLifetime:
						mySubMasks[AlertState_FieldPathSelectorLifetime] = common.FullTimeRange_FieldMask()
					}
				} else if tp, ok := path.(*AlertState_FieldSubPath); ok {
					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
				}
			} else {
				result.Paths = append(result.Paths, path)
			}
		}
	}
	for selector, mySubMask := range mySubMasks {
		if mySubMask.PathsCount() > 0 {
			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
				result.Paths = append(result.Paths, &AlertState_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

	if len(result.Paths) == 0 {
		return nil
	}
	return result
}

func (fieldMask *Alert_State_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*Alert_State_FieldMask))
}

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *Alert_State_FieldMask) FilterInputFields() *Alert_State_FieldMask {
	result := &Alert_State_FieldMask{}
	result.Paths = append(result.Paths, fieldMask.Paths...)
	return result
}

// ToFieldMask is used for proto conversions
func (fieldMask *Alert_State_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	for _, path := range fieldMask.Paths {
		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
	}
	return protoFieldMask
}

func (fieldMask *Alert_State_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
	if fieldMask == nil {
		return status.Error(codes.Internal, "target field mask is nil")
	}
	fieldMask.Paths = make([]AlertState_FieldPath, 0, len(protoFieldMask.Paths))
	for _, strPath := range protoFieldMask.Paths {
		path, err := ParseAlertState_FieldPath(strPath)
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, path)
	}
	return nil
}

// implement methods required by customType
func (fieldMask Alert_State_FieldMask) Marshal() ([]byte, error) {
	protoFieldMask := fieldMask.ToProtoFieldMask()
	return proto.Marshal(protoFieldMask)
}

func (fieldMask *Alert_State_FieldMask) Unmarshal(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_State_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

func (fieldMask Alert_State_FieldMask) MarshalJSON() ([]byte, error) {
	return json.Marshal(fieldMask.ToProtoFieldMask())
}

func (fieldMask *Alert_State_FieldMask) UnmarshalJSON(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := json.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_State_FieldMask) AppendPath(path AlertState_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

func (fieldMask *Alert_State_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path.(AlertState_FieldPath))
}

func (fieldMask *Alert_State_FieldMask) GetPaths() []AlertState_FieldPath {
	if fieldMask == nil {
		return nil
	}
	return fieldMask.Paths
}

func (fieldMask *Alert_State_FieldMask) GetRawPaths() []gotenobject.FieldPath {
	if fieldMask == nil {
		return nil
	}
	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		rawPaths = append(rawPaths, path)
	}
	return rawPaths
}

func (fieldMask *Alert_State_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseAlertState_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *Alert_State_FieldMask) Set(target, source *Alert_State) {
	for _, path := range fieldMask.Paths {
		val, _ := path.GetSingle(source)
		// if val is nil, then field does not exist in source, skip
		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
		if val != nil {
			path.WithIValue(val).SetTo(&target)
		}
	}
}

func (fieldMask *Alert_State_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*Alert_State), source.(*Alert_State))
}

func (fieldMask *Alert_State_FieldMask) Project(source *Alert_State) *Alert_State {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &Alert_State{}
	lifetimeMask := &common.TimeRange_FieldMask{}
	wholeLifetimeAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *AlertState_FieldTerminalPath:
			switch tp.selector {
			case AlertState_FieldPathSelectorIsFiring:
				result.IsFiring = source.IsFiring
			case AlertState_FieldPathSelectorIsAcknowledged:
				result.IsAcknowledged = source.IsAcknowledged
			case AlertState_FieldPathSelectorIsSilenced:
				result.IsSilenced = source.IsSilenced
			case AlertState_FieldPathSelectorLifetime:
				result.Lifetime = source.Lifetime
				wholeLifetimeAccepted = true
			case AlertState_FieldPathSelectorNeedsNotification:
				result.NeedsNotification = source.NeedsNotification
			case AlertState_FieldPathSelectorNotificationCreated:
				result.NotificationCreated = source.NotificationCreated
			case AlertState_FieldPathSelectorLifecycleCompleted:
				result.LifecycleCompleted = source.LifecycleCompleted
			}
		case *AlertState_FieldSubPath:
			switch tp.selector {
			case AlertState_FieldPathSelectorLifetime:
				lifetimeMask.AppendPath(tp.subPath.(common.TimeRange_FieldPath))
			}
		}
	}
	if wholeLifetimeAccepted == false && len(lifetimeMask.Paths) > 0 {
		result.Lifetime = lifetimeMask.Project(source.GetLifetime())
	}
	return result
}

func (fieldMask *Alert_State_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*Alert_State))
}

func (fieldMask *Alert_State_FieldMask) PathsCount() int {
	if fieldMask == nil {
		return 0
	}
	return len(fieldMask.Paths)
}

type Alert_Info_TimeSerie_FieldMask struct {
	Paths []AlertInfoTimeSerie_FieldPath
}

func FullAlert_Info_TimeSerie_FieldMask() *Alert_Info_TimeSerie_FieldMask {
	res := &Alert_Info_TimeSerie_FieldMask{}
	res.Paths = append(res.Paths, &AlertInfoTimeSerie_FieldTerminalPath{selector: AlertInfoTimeSerie_FieldPathSelectorKey})
	res.Paths = append(res.Paths, &AlertInfoTimeSerie_FieldTerminalPath{selector: AlertInfoTimeSerie_FieldPathSelectorMetric})
	res.Paths = append(res.Paths, &AlertInfoTimeSerie_FieldTerminalPath{selector: AlertInfoTimeSerie_FieldPathSelectorMonitoredResource})
	return res
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) String() string {
	if fieldMask == nil {
		return "<nil>"
	}
	pathsStr := make([]string, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		pathsStr = append(pathsStr, path.String())
	}
	return strings.Join(pathsStr, ", ")
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 3)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*AlertInfoTimeSerie_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) ProtoReflect() preflect.Message {
	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
		return ParseAlertInfoTimeSerie_FieldPath(raw)
	})
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) ProtoMessage() {}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) Reset() {
	if fieldMask != nil {
		fieldMask.Paths = nil
	}
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) Subtract(other *Alert_Info_TimeSerie_FieldMask) *Alert_Info_TimeSerie_FieldMask {
	result := &Alert_Info_TimeSerie_FieldMask{}
	removedSelectors := make([]bool, 3)
	otherSubMasks := map[AlertInfoTimeSerie_FieldPathSelector]gotenobject.FieldMask{
		AlertInfoTimeSerie_FieldPathSelectorMetric:            &common.Metric_FieldMask{},
		AlertInfoTimeSerie_FieldPathSelectorMonitoredResource: &common.MonitoredResource_FieldMask{},
	}
	mySubMasks := map[AlertInfoTimeSerie_FieldPathSelector]gotenobject.FieldMask{
		AlertInfoTimeSerie_FieldPathSelectorMetric:            &common.Metric_FieldMask{},
		AlertInfoTimeSerie_FieldPathSelectorMonitoredResource: &common.MonitoredResource_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *AlertInfoTimeSerie_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *AlertInfoTimeSerie_FieldSubPath:
			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
		}
	}
	for _, path := range fieldMask.GetPaths() {
		if !removedSelectors[int(path.Selector())] {
			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
				if tp, ok := path.(*AlertInfoTimeSerie_FieldTerminalPath); ok {
					switch tp.selector {
					case AlertInfoTimeSerie_FieldPathSelectorMetric:
						mySubMasks[AlertInfoTimeSerie_FieldPathSelectorMetric] = common.FullMetric_FieldMask()
					case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
						mySubMasks[AlertInfoTimeSerie_FieldPathSelectorMonitoredResource] = common.FullMonitoredResource_FieldMask()
					}
				} else if tp, ok := path.(*AlertInfoTimeSerie_FieldSubPath); ok {
					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
				}
			} else {
				result.Paths = append(result.Paths, path)
			}
		}
	}
	for selector, mySubMask := range mySubMasks {
		if mySubMask.PathsCount() > 0 {
			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
				result.Paths = append(result.Paths, &AlertInfoTimeSerie_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

	if len(result.Paths) == 0 {
		return nil
	}
	return result
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*Alert_Info_TimeSerie_FieldMask))
}

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *Alert_Info_TimeSerie_FieldMask) FilterInputFields() *Alert_Info_TimeSerie_FieldMask {
	result := &Alert_Info_TimeSerie_FieldMask{}
	result.Paths = append(result.Paths, fieldMask.Paths...)
	return result
}

// ToFieldMask is used for proto conversions
func (fieldMask *Alert_Info_TimeSerie_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	for _, path := range fieldMask.Paths {
		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
	}
	return protoFieldMask
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
	if fieldMask == nil {
		return status.Error(codes.Internal, "target field mask is nil")
	}
	fieldMask.Paths = make([]AlertInfoTimeSerie_FieldPath, 0, len(protoFieldMask.Paths))
	for _, strPath := range protoFieldMask.Paths {
		path, err := ParseAlertInfoTimeSerie_FieldPath(strPath)
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, path)
	}
	return nil
}

// implement methods required by customType
func (fieldMask Alert_Info_TimeSerie_FieldMask) Marshal() ([]byte, error) {
	protoFieldMask := fieldMask.ToProtoFieldMask()
	return proto.Marshal(protoFieldMask)
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) Unmarshal(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

func (fieldMask Alert_Info_TimeSerie_FieldMask) MarshalJSON() ([]byte, error) {
	return json.Marshal(fieldMask.ToProtoFieldMask())
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) UnmarshalJSON(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := json.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) AppendPath(path AlertInfoTimeSerie_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path.(AlertInfoTimeSerie_FieldPath))
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) GetPaths() []AlertInfoTimeSerie_FieldPath {
	if fieldMask == nil {
		return nil
	}
	return fieldMask.Paths
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) GetRawPaths() []gotenobject.FieldPath {
	if fieldMask == nil {
		return nil
	}
	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		rawPaths = append(rawPaths, path)
	}
	return rawPaths
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseAlertInfoTimeSerie_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) Set(target, source *Alert_Info_TimeSerie) {
	for _, path := range fieldMask.Paths {
		val, _ := path.GetSingle(source)
		// if val is nil, then field does not exist in source, skip
		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
		if val != nil {
			path.WithIValue(val).SetTo(&target)
		}
	}
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*Alert_Info_TimeSerie), source.(*Alert_Info_TimeSerie))
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) Project(source *Alert_Info_TimeSerie) *Alert_Info_TimeSerie {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &Alert_Info_TimeSerie{}
	metricMask := &common.Metric_FieldMask{}
	wholeMetricAccepted := false
	monitoredResourceMask := &common.MonitoredResource_FieldMask{}
	wholeMonitoredResourceAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *AlertInfoTimeSerie_FieldTerminalPath:
			switch tp.selector {
			case AlertInfoTimeSerie_FieldPathSelectorKey:
				result.Key = source.Key
			case AlertInfoTimeSerie_FieldPathSelectorMetric:
				result.Metric = source.Metric
				wholeMetricAccepted = true
			case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
				result.MonitoredResource = source.MonitoredResource
				wholeMonitoredResourceAccepted = true
			}
		case *AlertInfoTimeSerie_FieldSubPath:
			switch tp.selector {
			case AlertInfoTimeSerie_FieldPathSelectorMetric:
				metricMask.AppendPath(tp.subPath.(common.Metric_FieldPath))
			case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
				monitoredResourceMask.AppendPath(tp.subPath.(common.MonitoredResource_FieldPath))
			}
		}
	}
	if wholeMetricAccepted == false && len(metricMask.Paths) > 0 {
		result.Metric = metricMask.Project(source.GetMetric())
	}
	if wholeMonitoredResourceAccepted == false && len(monitoredResourceMask.Paths) > 0 {
		result.MonitoredResource = monitoredResourceMask.Project(source.GetMonitoredResource())
	}
	return result
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*Alert_Info_TimeSerie))
}

func (fieldMask *Alert_Info_TimeSerie_FieldMask) PathsCount() int {
	if fieldMask == nil {
		return 0
	}
	return len(fieldMask.Paths)
}

type Alert_Info_ObservedValues_FieldMask struct {
	Paths []AlertInfoObservedValues_FieldPath
}

func FullAlert_Info_ObservedValues_FieldMask() *Alert_Info_ObservedValues_FieldMask {
	res := &Alert_Info_ObservedValues_FieldMask{}
	res.Paths = append(res.Paths, &AlertInfoObservedValues_FieldTerminalPath{selector: AlertInfoObservedValues_FieldPathSelectorExampleValue})
	res.Paths = append(res.Paths, &AlertInfoObservedValues_FieldTerminalPath{selector: AlertInfoObservedValues_FieldPathSelectorPerMetric})
	return res
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) String() string {
	if fieldMask == nil {
		return "<nil>"
	}
	pathsStr := make([]string, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		pathsStr = append(pathsStr, path.String())
	}
	return strings.Join(pathsStr, ", ")
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 2)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*AlertInfoObservedValues_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) ProtoReflect() preflect.Message {
	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
		return ParseAlertInfoObservedValues_FieldPath(raw)
	})
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) ProtoMessage() {}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) Reset() {
	if fieldMask != nil {
		fieldMask.Paths = nil
	}
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) Subtract(other *Alert_Info_ObservedValues_FieldMask) *Alert_Info_ObservedValues_FieldMask {
	result := &Alert_Info_ObservedValues_FieldMask{}
	removedSelectors := make([]bool, 2)

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *AlertInfoObservedValues_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		}
	}
	for _, path := range fieldMask.GetPaths() {
		if !removedSelectors[int(path.Selector())] {
			result.Paths = append(result.Paths, path)
		}
	}

	if len(result.Paths) == 0 {
		return nil
	}
	return result
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*Alert_Info_ObservedValues_FieldMask))
}

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *Alert_Info_ObservedValues_FieldMask) FilterInputFields() *Alert_Info_ObservedValues_FieldMask {
	result := &Alert_Info_ObservedValues_FieldMask{}
	result.Paths = append(result.Paths, fieldMask.Paths...)
	return result
}

// ToFieldMask is used for proto conversions
func (fieldMask *Alert_Info_ObservedValues_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	for _, path := range fieldMask.Paths {
		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
	}
	return protoFieldMask
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
	if fieldMask == nil {
		return status.Error(codes.Internal, "target field mask is nil")
	}
	fieldMask.Paths = make([]AlertInfoObservedValues_FieldPath, 0, len(protoFieldMask.Paths))
	for _, strPath := range protoFieldMask.Paths {
		path, err := ParseAlertInfoObservedValues_FieldPath(strPath)
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, path)
	}
	return nil
}

// implement methods required by customType
func (fieldMask Alert_Info_ObservedValues_FieldMask) Marshal() ([]byte, error) {
	protoFieldMask := fieldMask.ToProtoFieldMask()
	return proto.Marshal(protoFieldMask)
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) Unmarshal(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

func (fieldMask Alert_Info_ObservedValues_FieldMask) MarshalJSON() ([]byte, error) {
	return json.Marshal(fieldMask.ToProtoFieldMask())
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) UnmarshalJSON(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := json.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) AppendPath(path AlertInfoObservedValues_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path.(AlertInfoObservedValues_FieldPath))
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) GetPaths() []AlertInfoObservedValues_FieldPath {
	if fieldMask == nil {
		return nil
	}
	return fieldMask.Paths
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) GetRawPaths() []gotenobject.FieldPath {
	if fieldMask == nil {
		return nil
	}
	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		rawPaths = append(rawPaths, path)
	}
	return rawPaths
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseAlertInfoObservedValues_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) Set(target, source *Alert_Info_ObservedValues) {
	for _, path := range fieldMask.Paths {
		val, _ := path.GetSingle(source)
		// if val is nil, then field does not exist in source, skip
		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
		if val != nil {
			path.WithIValue(val).SetTo(&target)
		}
	}
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*Alert_Info_ObservedValues), source.(*Alert_Info_ObservedValues))
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) Project(source *Alert_Info_ObservedValues) *Alert_Info_ObservedValues {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &Alert_Info_ObservedValues{}
	var perMetricMapKeys []string
	wholePerMetricAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *AlertInfoObservedValues_FieldTerminalPath:
			switch tp.selector {
			case AlertInfoObservedValues_FieldPathSelectorExampleValue:
				result.ExampleValue = source.ExampleValue
			case AlertInfoObservedValues_FieldPathSelectorPerMetric:
				result.PerMetric = source.PerMetric
				wholePerMetricAccepted = true
			}
		case *AlertInfoObservedValues_FieldPathMap:
			switch tp.selector {
			case AlertInfoObservedValues_FieldPathSelectorPerMetric:
				perMetricMapKeys = append(perMetricMapKeys, tp.key)
			}
		}
	}
	if wholePerMetricAccepted == false && len(perMetricMapKeys) > 0 && source.GetPerMetric() != nil {
		copiedMap := map[string]float64{}
		sourceMap := source.GetPerMetric()
		for _, key := range perMetricMapKeys {
			copiedMap[key] = sourceMap[key]
		}
		result.PerMetric = copiedMap
	}
	return result
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*Alert_Info_ObservedValues))
}

func (fieldMask *Alert_Info_ObservedValues_FieldMask) PathsCount() int {
	if fieldMask == nil {
		return 0
	}
	return len(fieldMask.Paths)
}

type Alert_State_Threshold_FieldMask struct {
	Paths []AlertStateThreshold_FieldPath
}

func FullAlert_State_Threshold_FieldMask() *Alert_State_Threshold_FieldMask {
	res := &Alert_State_Threshold_FieldMask{}
	res.Paths = append(res.Paths, &AlertStateThreshold_FieldTerminalPath{selector: AlertStateThreshold_FieldPathSelectorObservedValue})
	return res
}

func (fieldMask *Alert_State_Threshold_FieldMask) String() string {
	if fieldMask == nil {
		return "<nil>"
	}
	pathsStr := make([]string, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		pathsStr = append(pathsStr, path.String())
	}
	return strings.Join(pathsStr, ", ")
}

func (fieldMask *Alert_State_Threshold_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 1)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*AlertStateThreshold_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

func (fieldMask *Alert_State_Threshold_FieldMask) ProtoReflect() preflect.Message {
	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
		return ParseAlertStateThreshold_FieldPath(raw)
	})
}

func (fieldMask *Alert_State_Threshold_FieldMask) ProtoMessage() {}

func (fieldMask *Alert_State_Threshold_FieldMask) Reset() {
	if fieldMask != nil {
		fieldMask.Paths = nil
	}
}

func (fieldMask *Alert_State_Threshold_FieldMask) Subtract(other *Alert_State_Threshold_FieldMask) *Alert_State_Threshold_FieldMask {
	result := &Alert_State_Threshold_FieldMask{}
	removedSelectors := make([]bool, 1)

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *AlertStateThreshold_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		}
	}
	for _, path := range fieldMask.GetPaths() {
		if !removedSelectors[int(path.Selector())] {
			result.Paths = append(result.Paths, path)
		}
	}

	if len(result.Paths) == 0 {
		return nil
	}
	return result
}

func (fieldMask *Alert_State_Threshold_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*Alert_State_Threshold_FieldMask))
}

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *Alert_State_Threshold_FieldMask) FilterInputFields() *Alert_State_Threshold_FieldMask {
	result := &Alert_State_Threshold_FieldMask{}
	result.Paths = append(result.Paths, fieldMask.Paths...)
	return result
}

// ToFieldMask is used for proto conversions
func (fieldMask *Alert_State_Threshold_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	for _, path := range fieldMask.Paths {
		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
	}
	return protoFieldMask
}

func (fieldMask *Alert_State_Threshold_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
	if fieldMask == nil {
		return status.Error(codes.Internal, "target field mask is nil")
	}
	fieldMask.Paths = make([]AlertStateThreshold_FieldPath, 0, len(protoFieldMask.Paths))
	for _, strPath := range protoFieldMask.Paths {
		path, err := ParseAlertStateThreshold_FieldPath(strPath)
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, path)
	}
	return nil
}

// implement methods required by customType
func (fieldMask Alert_State_Threshold_FieldMask) Marshal() ([]byte, error) {
	protoFieldMask := fieldMask.ToProtoFieldMask()
	return proto.Marshal(protoFieldMask)
}

func (fieldMask *Alert_State_Threshold_FieldMask) Unmarshal(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_State_Threshold_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

func (fieldMask Alert_State_Threshold_FieldMask) MarshalJSON() ([]byte, error) {
	return json.Marshal(fieldMask.ToProtoFieldMask())
}

func (fieldMask *Alert_State_Threshold_FieldMask) UnmarshalJSON(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := json.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_State_Threshold_FieldMask) AppendPath(path AlertStateThreshold_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

func (fieldMask *Alert_State_Threshold_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path.(AlertStateThreshold_FieldPath))
}

func (fieldMask *Alert_State_Threshold_FieldMask) GetPaths() []AlertStateThreshold_FieldPath {
	if fieldMask == nil {
		return nil
	}
	return fieldMask.Paths
}

func (fieldMask *Alert_State_Threshold_FieldMask) GetRawPaths() []gotenobject.FieldPath {
	if fieldMask == nil {
		return nil
	}
	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		rawPaths = append(rawPaths, path)
	}
	return rawPaths
}

func (fieldMask *Alert_State_Threshold_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseAlertStateThreshold_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *Alert_State_Threshold_FieldMask) Set(target, source *Alert_State_Threshold) {
	for _, path := range fieldMask.Paths {
		val, _ := path.GetSingle(source)
		// if val is nil, then field does not exist in source, skip
		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
		if val != nil {
			path.WithIValue(val).SetTo(&target)
		}
	}
}

func (fieldMask *Alert_State_Threshold_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*Alert_State_Threshold), source.(*Alert_State_Threshold))
}

func (fieldMask *Alert_State_Threshold_FieldMask) Project(source *Alert_State_Threshold) *Alert_State_Threshold {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &Alert_State_Threshold{}

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *AlertStateThreshold_FieldTerminalPath:
			switch tp.selector {
			case AlertStateThreshold_FieldPathSelectorObservedValue:
				result.ObservedValue = source.ObservedValue
			}
		}
	}
	return result
}

func (fieldMask *Alert_State_Threshold_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*Alert_State_Threshold))
}

func (fieldMask *Alert_State_Threshold_FieldMask) PathsCount() int {
	if fieldMask == nil {
		return 0
	}
	return len(fieldMask.Paths)
}

type Alert_State_CombineThreshold_FieldMask struct {
	Paths []AlertStateCombineThreshold_FieldPath
}

func FullAlert_State_CombineThreshold_FieldMask() *Alert_State_CombineThreshold_FieldMask {
	res := &Alert_State_CombineThreshold_FieldMask{}
	return res
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) String() string {
	if fieldMask == nil {
		return "<nil>"
	}
	pathsStr := make([]string, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		pathsStr = append(pathsStr, path.String())
	}
	return strings.Join(pathsStr, ", ")
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 0)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*AlertStateCombineThreshold_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) ProtoReflect() preflect.Message {
	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
		return ParseAlertStateCombineThreshold_FieldPath(raw)
	})
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) ProtoMessage() {}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) Reset() {
	if fieldMask != nil {
		fieldMask.Paths = nil
	}
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) Subtract(other *Alert_State_CombineThreshold_FieldMask) *Alert_State_CombineThreshold_FieldMask {
	result := &Alert_State_CombineThreshold_FieldMask{}
	removedSelectors := make([]bool, 0)

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *AlertStateCombineThreshold_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		}
	}
	for _, path := range fieldMask.GetPaths() {
		if !removedSelectors[int(path.Selector())] {
			result.Paths = append(result.Paths, path)
		}
	}

	if len(result.Paths) == 0 {
		return nil
	}
	return result
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*Alert_State_CombineThreshold_FieldMask))
}

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *Alert_State_CombineThreshold_FieldMask) FilterInputFields() *Alert_State_CombineThreshold_FieldMask {
	result := &Alert_State_CombineThreshold_FieldMask{}
	result.Paths = append(result.Paths, fieldMask.Paths...)
	return result
}

// ToFieldMask is used for proto conversions
func (fieldMask *Alert_State_CombineThreshold_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	for _, path := range fieldMask.Paths {
		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
	}
	return protoFieldMask
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
	if fieldMask == nil {
		return status.Error(codes.Internal, "target field mask is nil")
	}
	fieldMask.Paths = make([]AlertStateCombineThreshold_FieldPath, 0, len(protoFieldMask.Paths))
	for _, strPath := range protoFieldMask.Paths {
		path, err := ParseAlertStateCombineThreshold_FieldPath(strPath)
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, path)
	}
	return nil
}

// implement methods required by customType
func (fieldMask Alert_State_CombineThreshold_FieldMask) Marshal() ([]byte, error) {
	protoFieldMask := fieldMask.ToProtoFieldMask()
	return proto.Marshal(protoFieldMask)
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) Unmarshal(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

func (fieldMask Alert_State_CombineThreshold_FieldMask) MarshalJSON() ([]byte, error) {
	return json.Marshal(fieldMask.ToProtoFieldMask())
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) UnmarshalJSON(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := json.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) AppendPath(path AlertStateCombineThreshold_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path.(AlertStateCombineThreshold_FieldPath))
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) GetPaths() []AlertStateCombineThreshold_FieldPath {
	if fieldMask == nil {
		return nil
	}
	return fieldMask.Paths
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) GetRawPaths() []gotenobject.FieldPath {
	if fieldMask == nil {
		return nil
	}
	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		rawPaths = append(rawPaths, path)
	}
	return rawPaths
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseAlertStateCombineThreshold_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) Set(target, source *Alert_State_CombineThreshold) {
	for _, path := range fieldMask.Paths {
		val, _ := path.GetSingle(source)
		// if val is nil, then field does not exist in source, skip
		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
		if val != nil {
			path.WithIValue(val).SetTo(&target)
		}
	}
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*Alert_State_CombineThreshold), source.(*Alert_State_CombineThreshold))
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) Project(source *Alert_State_CombineThreshold) *Alert_State_CombineThreshold {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &Alert_State_CombineThreshold{}

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *AlertStateCombineThreshold_FieldTerminalPath:
			switch tp.selector {
			}
		}
	}
	return result
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*Alert_State_CombineThreshold))
}

func (fieldMask *Alert_State_CombineThreshold_FieldMask) PathsCount() int {
	if fieldMask == nil {
		return 0
	}
	return len(fieldMask.Paths)
}

type Alert_State_CombineThreshold_PerMetric_FieldMask struct {
	Paths []AlertStateCombineThresholdPerMetric_FieldPath
}

func FullAlert_State_CombineThreshold_PerMetric_FieldMask() *Alert_State_CombineThreshold_PerMetric_FieldMask {
	res := &Alert_State_CombineThreshold_PerMetric_FieldMask{}
	res.Paths = append(res.Paths, &AlertStateCombineThresholdPerMetric_FieldTerminalPath{selector: AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues})
	return res
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) String() string {
	if fieldMask == nil {
		return "<nil>"
	}
	pathsStr := make([]string, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		pathsStr = append(pathsStr, path.String())
	}
	return strings.Join(pathsStr, ", ")
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 1)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*AlertStateCombineThresholdPerMetric_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) ProtoReflect() preflect.Message {
	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
		return ParseAlertStateCombineThresholdPerMetric_FieldPath(raw)
	})
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) ProtoMessage() {}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) Reset() {
	if fieldMask != nil {
		fieldMask.Paths = nil
	}
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) Subtract(other *Alert_State_CombineThreshold_PerMetric_FieldMask) *Alert_State_CombineThreshold_PerMetric_FieldMask {
	result := &Alert_State_CombineThreshold_PerMetric_FieldMask{}
	removedSelectors := make([]bool, 1)

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *AlertStateCombineThresholdPerMetric_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		}
	}
	for _, path := range fieldMask.GetPaths() {
		if !removedSelectors[int(path.Selector())] {
			result.Paths = append(result.Paths, path)
		}
	}

	if len(result.Paths) == 0 {
		return nil
	}
	return result
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*Alert_State_CombineThreshold_PerMetric_FieldMask))
}

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) FilterInputFields() *Alert_State_CombineThreshold_PerMetric_FieldMask {
	result := &Alert_State_CombineThreshold_PerMetric_FieldMask{}
	result.Paths = append(result.Paths, fieldMask.Paths...)
	return result
}

// ToFieldMask is used for proto conversions
func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	for _, path := range fieldMask.Paths {
		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
	}
	return protoFieldMask
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
	if fieldMask == nil {
		return status.Error(codes.Internal, "target field mask is nil")
	}
	fieldMask.Paths = make([]AlertStateCombineThresholdPerMetric_FieldPath, 0, len(protoFieldMask.Paths))
	for _, strPath := range protoFieldMask.Paths {
		path, err := ParseAlertStateCombineThresholdPerMetric_FieldPath(strPath)
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, path)
	}
	return nil
}

// implement methods required by customType
func (fieldMask Alert_State_CombineThreshold_PerMetric_FieldMask) Marshal() ([]byte, error) {
	protoFieldMask := fieldMask.ToProtoFieldMask()
	return proto.Marshal(protoFieldMask)
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) Unmarshal(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

func (fieldMask Alert_State_CombineThreshold_PerMetric_FieldMask) MarshalJSON() ([]byte, error) {
	return json.Marshal(fieldMask.ToProtoFieldMask())
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) UnmarshalJSON(data []byte) error {
	protoFieldMask := &googlefieldmaskpb.FieldMask{}
	if err := json.Unmarshal(data, protoFieldMask); err != nil {
		return err
	}
	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
		return err
	}
	return nil
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) AppendPath(path AlertStateCombineThresholdPerMetric_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path.(AlertStateCombineThresholdPerMetric_FieldPath))
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) GetPaths() []AlertStateCombineThresholdPerMetric_FieldPath {
	if fieldMask == nil {
		return nil
	}
	return fieldMask.Paths
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) GetRawPaths() []gotenobject.FieldPath {
	if fieldMask == nil {
		return nil
	}
	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.Paths {
		rawPaths = append(rawPaths, path)
	}
	return rawPaths
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseAlertStateCombineThresholdPerMetric_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) Set(target, source *Alert_State_CombineThreshold_PerMetric) {
	for _, path := range fieldMask.Paths {
		val, _ := path.GetSingle(source)
		// if val is nil, then field does not exist in source, skip
		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
		if val != nil {
			path.WithIValue(val).SetTo(&target)
		}
	}
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*Alert_State_CombineThreshold_PerMetric), source.(*Alert_State_CombineThreshold_PerMetric))
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) Project(source *Alert_State_CombineThreshold_PerMetric) *Alert_State_CombineThreshold_PerMetric {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &Alert_State_CombineThreshold_PerMetric{}
	var observedValuesMapKeys []string
	wholeObservedValuesAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *AlertStateCombineThresholdPerMetric_FieldTerminalPath:
			switch tp.selector {
			case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
				result.ObservedValues = source.ObservedValues
				wholeObservedValuesAccepted = true
			}
		case *AlertStateCombineThresholdPerMetric_FieldPathMap:
			switch tp.selector {
			case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
				observedValuesMapKeys = append(observedValuesMapKeys, tp.key)
			}
		}
	}
	if wholeObservedValuesAccepted == false && len(observedValuesMapKeys) > 0 && source.GetObservedValues() != nil {
		copiedMap := map[string]float64{}
		sourceMap := source.GetObservedValues()
		for _, key := range observedValuesMapKeys {
			copiedMap[key] = sourceMap[key]
		}
		result.ObservedValues = copiedMap
	}
	return result
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*Alert_State_CombineThreshold_PerMetric))
}

func (fieldMask *Alert_State_CombineThreshold_PerMetric_FieldMask) PathsCount() int {
	if fieldMask == nil {
		return 0
	}
	return len(fieldMask.Paths)
}