github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/resources/v1/notifications/notification_msg.pb.fieldmask.go

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

package notification_msg

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 (
	alert "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/alert"
	rcommon "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/common"
	log_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/log_condition"
	policy "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/policy"
	ts_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/ts_condition"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// ensure the imports are used
var (
	_ = new(json.Marshaler)
	_ = 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 (
	_ = &alert.Alert{}
	_ = &log_condition.LogCondition{}
	_ = &policy.Policy{}
	_ = &rcommon.LogCndSpec{}
	_ = &ts_condition.TsCondition{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &durationpb.Duration{}
	_ = &timestamppb.Timestamp{}
)

type NotificationMsg_FieldMask struct {
	Paths []NotificationMsg_FieldPath
}

func FullNotificationMsg_FieldMask() *NotificationMsg_FieldMask {
	res := &NotificationMsg_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorProjectFqn})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorProjectDisplayName})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorOrganizationFqn})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorOrganizationDisplayName})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorPolicyFqn})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorPolicyDisplayName})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorNewFiringAlerts})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied})
	res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorStoppedAlerts})
	return res
}

func (fieldMask *NotificationMsg_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 *NotificationMsg_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 14)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsg_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_FieldMask) ProtoMessage() {}

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

func (fieldMask *NotificationMsg_FieldMask) Subtract(other *NotificationMsg_FieldMask) *NotificationMsg_FieldMask {
	result := &NotificationMsg_FieldMask{}
	removedSelectors := make([]bool, 14)
	otherSubMasks := map[NotificationMsg_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsg_FieldPathSelectorNewFiringAlerts:                            &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:              &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation: &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:                  &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:  &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:             &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:       &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorStoppedAlerts:                              &NotificationMsg_AlertsGroup_FieldMask{},
	}
	mySubMasks := map[NotificationMsg_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsg_FieldPathSelectorNewFiringAlerts:                            &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:              &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation: &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:                  &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:  &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:             &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:       &NotificationMsg_AlertsGroup_FieldMask{},
		NotificationMsg_FieldPathSelectorStoppedAlerts:                              &NotificationMsg_AlertsGroup_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsg_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsg_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.(*NotificationMsg_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsg_FieldPathSelectorNewFiringAlerts:
						mySubMasks[NotificationMsg_FieldPathSelectorNewFiringAlerts] = FullNotificationMsg_AlertsGroup_FieldMask()
					case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
						mySubMasks[NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator] = FullNotificationMsg_AlertsGroup_FieldMask()
					case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
						mySubMasks[NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation] = FullNotificationMsg_AlertsGroup_FieldMask()
					case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
						mySubMasks[NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi] = FullNotificationMsg_AlertsGroup_FieldMask()
					case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
						mySubMasks[NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi] = FullNotificationMsg_AlertsGroup_FieldMask()
					case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
						mySubMasks[NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied] = FullNotificationMsg_AlertsGroup_FieldMask()
					case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
						mySubMasks[NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied] = FullNotificationMsg_AlertsGroup_FieldMask()
					case NotificationMsg_FieldPathSelectorStoppedAlerts:
						mySubMasks[NotificationMsg_FieldPathSelectorStoppedAlerts] = FullNotificationMsg_AlertsGroup_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsg_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, &NotificationMsg_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_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 *NotificationMsg_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_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 *NotificationMsg_FieldMask) AppendPath(path NotificationMsg_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_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 *NotificationMsg_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsg_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_FieldMask) Set(target, source *NotificationMsg) {
	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 *NotificationMsg_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg), source.(*NotificationMsg))
}

func (fieldMask *NotificationMsg_FieldMask) Project(source *NotificationMsg) *NotificationMsg {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg{}
	newFiringAlertsMask := &NotificationMsg_AlertsGroup_FieldMask{}
	wholeNewFiringAlertsAccepted := false
	alertsEscalatedByAiToOperatorMask := &NotificationMsg_AlertsGroup_FieldMask{}
	wholeAlertsEscalatedByAiToOperatorAccepted := false
	alertsAwaitingForApprovalWithAiRemediationMask := &NotificationMsg_AlertsGroup_FieldMask{}
	wholeAlertsAwaitingForApprovalWithAiRemediationAccepted := false
	alertsFlaggedToIgnoreByAiMask := &NotificationMsg_AlertsGroup_FieldMask{}
	wholeAlertsFlaggedToIgnoreByAiAccepted := false
	alertsWithConditionMarkedForAdjustingByAiMask := &NotificationMsg_AlertsGroup_FieldMask{}
	wholeAlertsWithConditionMarkedForAdjustingByAiAccepted := false
	alertsWithAiRemediationAppliedMask := &NotificationMsg_AlertsGroup_FieldMask{}
	wholeAlertsWithAiRemediationAppliedAccepted := false
	alertsWithOperatorRemediationAppliedMask := &NotificationMsg_AlertsGroup_FieldMask{}
	wholeAlertsWithOperatorRemediationAppliedAccepted := false
	stoppedAlertsMask := &NotificationMsg_AlertsGroup_FieldMask{}
	wholeStoppedAlertsAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsg_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsg_FieldPathSelectorProjectFqn:
				result.ProjectFqn = source.ProjectFqn
			case NotificationMsg_FieldPathSelectorProjectDisplayName:
				result.ProjectDisplayName = source.ProjectDisplayName
			case NotificationMsg_FieldPathSelectorOrganizationFqn:
				result.OrganizationFqn = source.OrganizationFqn
			case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
				result.OrganizationDisplayName = source.OrganizationDisplayName
			case NotificationMsg_FieldPathSelectorPolicyFqn:
				result.PolicyFqn = source.PolicyFqn
			case NotificationMsg_FieldPathSelectorPolicyDisplayName:
				result.PolicyDisplayName = source.PolicyDisplayName
			case NotificationMsg_FieldPathSelectorNewFiringAlerts:
				result.NewFiringAlerts = source.NewFiringAlerts
				wholeNewFiringAlertsAccepted = true
			case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
				result.AlertsEscalatedByAiToOperator = source.AlertsEscalatedByAiToOperator
				wholeAlertsEscalatedByAiToOperatorAccepted = true
			case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
				result.AlertsAwaitingForApprovalWithAiRemediation = source.AlertsAwaitingForApprovalWithAiRemediation
				wholeAlertsAwaitingForApprovalWithAiRemediationAccepted = true
			case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
				result.AlertsFlaggedToIgnoreByAi = source.AlertsFlaggedToIgnoreByAi
				wholeAlertsFlaggedToIgnoreByAiAccepted = true
			case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
				result.AlertsWithConditionMarkedForAdjustingByAi = source.AlertsWithConditionMarkedForAdjustingByAi
				wholeAlertsWithConditionMarkedForAdjustingByAiAccepted = true
			case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
				result.AlertsWithAiRemediationApplied = source.AlertsWithAiRemediationApplied
				wholeAlertsWithAiRemediationAppliedAccepted = true
			case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
				result.AlertsWithOperatorRemediationApplied = source.AlertsWithOperatorRemediationApplied
				wholeAlertsWithOperatorRemediationAppliedAccepted = true
			case NotificationMsg_FieldPathSelectorStoppedAlerts:
				result.StoppedAlerts = source.StoppedAlerts
				wholeStoppedAlertsAccepted = true
			}
		case *NotificationMsg_FieldSubPath:
			switch tp.selector {
			case NotificationMsg_FieldPathSelectorNewFiringAlerts:
				newFiringAlertsMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroup_FieldPath))
			case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
				alertsEscalatedByAiToOperatorMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroup_FieldPath))
			case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
				alertsAwaitingForApprovalWithAiRemediationMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroup_FieldPath))
			case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
				alertsFlaggedToIgnoreByAiMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroup_FieldPath))
			case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
				alertsWithConditionMarkedForAdjustingByAiMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroup_FieldPath))
			case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
				alertsWithAiRemediationAppliedMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroup_FieldPath))
			case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
				alertsWithOperatorRemediationAppliedMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroup_FieldPath))
			case NotificationMsg_FieldPathSelectorStoppedAlerts:
				stoppedAlertsMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroup_FieldPath))
			}
		}
	}
	if wholeNewFiringAlertsAccepted == false && len(newFiringAlertsMask.Paths) > 0 {
		result.NewFiringAlerts = newFiringAlertsMask.Project(source.GetNewFiringAlerts())
	}
	if wholeAlertsEscalatedByAiToOperatorAccepted == false && len(alertsEscalatedByAiToOperatorMask.Paths) > 0 {
		result.AlertsEscalatedByAiToOperator = alertsEscalatedByAiToOperatorMask.Project(source.GetAlertsEscalatedByAiToOperator())
	}
	if wholeAlertsAwaitingForApprovalWithAiRemediationAccepted == false && len(alertsAwaitingForApprovalWithAiRemediationMask.Paths) > 0 {
		result.AlertsAwaitingForApprovalWithAiRemediation = alertsAwaitingForApprovalWithAiRemediationMask.Project(source.GetAlertsAwaitingForApprovalWithAiRemediation())
	}
	if wholeAlertsFlaggedToIgnoreByAiAccepted == false && len(alertsFlaggedToIgnoreByAiMask.Paths) > 0 {
		result.AlertsFlaggedToIgnoreByAi = alertsFlaggedToIgnoreByAiMask.Project(source.GetAlertsFlaggedToIgnoreByAi())
	}
	if wholeAlertsWithConditionMarkedForAdjustingByAiAccepted == false && len(alertsWithConditionMarkedForAdjustingByAiMask.Paths) > 0 {
		result.AlertsWithConditionMarkedForAdjustingByAi = alertsWithConditionMarkedForAdjustingByAiMask.Project(source.GetAlertsWithConditionMarkedForAdjustingByAi())
	}
	if wholeAlertsWithAiRemediationAppliedAccepted == false && len(alertsWithAiRemediationAppliedMask.Paths) > 0 {
		result.AlertsWithAiRemediationApplied = alertsWithAiRemediationAppliedMask.Project(source.GetAlertsWithAiRemediationApplied())
	}
	if wholeAlertsWithOperatorRemediationAppliedAccepted == false && len(alertsWithOperatorRemediationAppliedMask.Paths) > 0 {
		result.AlertsWithOperatorRemediationApplied = alertsWithOperatorRemediationAppliedMask.Project(source.GetAlertsWithOperatorRemediationApplied())
	}
	if wholeStoppedAlertsAccepted == false && len(stoppedAlertsMask.Paths) > 0 {
		result.StoppedAlerts = stoppedAlertsMask.Project(source.GetStoppedAlerts())
	}
	return result
}

func (fieldMask *NotificationMsg_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg))
}

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

type NotificationMsg_AlertsGroup_FieldMask struct {
	Paths []NotificationMsgAlertsGroup_FieldPath
}

func FullNotificationMsg_AlertsGroup_FieldMask() *NotificationMsg_AlertsGroup_FieldMask {
	res := &NotificationMsg_AlertsGroup_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroup_FieldTerminalPath{selector: NotificationMsgAlertsGroup_FieldPathSelectorByCondition})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_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 *NotificationMsg_AlertsGroup_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 1)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroup_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_FieldMask) ProtoMessage() {}

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

func (fieldMask *NotificationMsg_AlertsGroup_FieldMask) Subtract(other *NotificationMsg_AlertsGroup_FieldMask) *NotificationMsg_AlertsGroup_FieldMask {
	result := &NotificationMsg_AlertsGroup_FieldMask{}
	removedSelectors := make([]bool, 1)
	otherSubMasks := map[NotificationMsgAlertsGroup_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroup_FieldPathSelectorByCondition: &NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask{},
	}
	mySubMasks := map[NotificationMsgAlertsGroup_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroup_FieldPathSelectorByCondition: &NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroup_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsgAlertsGroup_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.(*NotificationMsgAlertsGroup_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsgAlertsGroup_FieldPathSelectorByCondition:
						mySubMasks[NotificationMsgAlertsGroup_FieldPathSelectorByCondition] = FullNotificationMsg_AlertsGroup_ConditionAlerts_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsgAlertsGroup_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, &NotificationMsgAlertsGroup_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_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 *NotificationMsg_AlertsGroup_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_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 *NotificationMsg_AlertsGroup_FieldMask) AppendPath(path NotificationMsgAlertsGroup_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_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 *NotificationMsg_AlertsGroup_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroup_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_FieldMask) Set(target, source *NotificationMsg_AlertsGroup) {
	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 *NotificationMsg_AlertsGroup_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup), source.(*NotificationMsg_AlertsGroup))
}

func (fieldMask *NotificationMsg_AlertsGroup_FieldMask) Project(source *NotificationMsg_AlertsGroup) *NotificationMsg_AlertsGroup {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup{}
	byConditionMask := &NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask{}
	wholeByConditionAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroup_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroup_FieldPathSelectorByCondition:
				result.ByCondition = source.ByCondition
				wholeByConditionAccepted = true
			}
		case *NotificationMsgAlertsGroup_FieldSubPath:
			switch tp.selector {
			case NotificationMsgAlertsGroup_FieldPathSelectorByCondition:
				byConditionMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlerts_FieldPath))
			}
		}
	}
	if wholeByConditionAccepted == false && len(byConditionMask.Paths) > 0 {
		for _, sourceItem := range source.GetByCondition() {
			result.ByCondition = append(result.ByCondition, byConditionMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlerts_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_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 *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 4)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) ProtoMessage() {}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) Subtract(other *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask {
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask{}
	removedSelectors := make([]bool, 4)
	otherSubMasks := map[NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition: &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask{},
		NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:        &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask{},
		NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:              &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask{},
	}
	mySubMasks := map[NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition: &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask{},
		NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:        &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask{},
		NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:              &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsgAlertsGroupConditionAlerts_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.(*NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
						mySubMasks[NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition] = FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask()
					case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
						mySubMasks[NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition] = FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask()
					case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
						mySubMasks[NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts] = FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsgAlertsGroupConditionAlerts_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, &NotificationMsgAlertsGroupConditionAlerts_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_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 *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_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 *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlerts_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_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 *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlerts_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts), source.(*NotificationMsg_AlertsGroup_ConditionAlerts))
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) Project(source *NotificationMsg_AlertsGroup_ConditionAlerts) *NotificationMsg_AlertsGroup_ConditionAlerts {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts{}
	timeSeriesConditionMask := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask{}
	wholeTimeSeriesConditionAccepted := false
	logConditionMask := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask{}
	wholeLogConditionAccepted := false
	alertsMask := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask{}
	wholeAlertsAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
				if source, ok := source.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); ok {
					result.Type = &NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition{
						TimeSeriesCondition: source.TimeSeriesCondition,
					}
				}
				wholeTimeSeriesConditionAccepted = true
			case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
				if source, ok := source.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); ok {
					result.Type = &NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition{
						LogCondition: source.LogCondition,
					}
				}
				wholeLogConditionAccepted = true
			case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
				result.Alerts = source.Alerts
				wholeAlertsAccepted = true
			case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
				result.MoreAlertsCount = source.MoreAlertsCount
			}
		case *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
				timeSeriesConditionMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath))
			case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
				logConditionMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath))
			case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
				alertsMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath))
			}
		}
	}
	if wholeTimeSeriesConditionAccepted == false && len(timeSeriesConditionMask.Paths) > 0 {
		if asOneOf, ok := source.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); ok {
			result.Type = (*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition)(nil)
			if asOneOf != nil {
				oneOfRes := &NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition{}
				oneOfRes.TimeSeriesCondition = timeSeriesConditionMask.Project(asOneOf.TimeSeriesCondition)
				result.Type = oneOfRes
			}
		}
	}
	if wholeLogConditionAccepted == false && len(logConditionMask.Paths) > 0 {
		if asOneOf, ok := source.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); ok {
			result.Type = (*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition)(nil)
			if asOneOf != nil {
				oneOfRes := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition{}
				oneOfRes.LogCondition = logConditionMask.Project(asOneOf.LogCondition)
				result.Type = oneOfRes
			}
		}
	}
	if wholeAlertsAccepted == false && len(alertsMask.Paths) > 0 {
		for _, sourceItem := range source.GetAlerts() {
			result.Alerts = append(result.Alerts, alertsMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 3)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) ProtoMessage() {}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) Subtract(other *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask {
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask{}
	removedSelectors := make([]bool, 3)
	otherSubMasks := map[NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries: &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask{},
	}
	mySubMasks := map[NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries: &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsgAlertsGroupConditionAlertsTsCndType_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.(*NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries] = FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsgAlertsGroupConditionAlertsTsCndType_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, &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType))
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) Project(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType{}
	queriesMask := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask{}
	wholeQueriesAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
				result.Fqn = source.Fqn
			case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
				result.DisplayName = source.DisplayName
			case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
				result.Queries = source.Queries
				wholeQueriesAccepted = true
			}
		case *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
				queriesMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath))
			}
		}
	}
	if wholeQueriesAccepted == false && len(queriesMask.Paths) > 0 {
		for _, sourceItem := range source.GetQueries() {
			result.Queries = append(result.Queries, queriesMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 3)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) ProtoMessage() {}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) Subtract(other *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask {
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask{}
	removedSelectors := make([]bool, 3)
	otherSubMasks := map[NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries: &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask{},
	}
	mySubMasks := map[NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries: &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsgAlertsGroupConditionAlertsLogCndType_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.(*NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries] = FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsgAlertsGroupConditionAlertsLogCndType_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, &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType))
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) Project(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType{}
	queriesMask := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask{}
	wholeQueriesAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
				result.Fqn = source.Fqn
			case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
				result.DisplayName = source.DisplayName
			case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
				result.Queries = source.Queries
				wholeQueriesAccepted = true
			}
		case *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
				queriesMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath))
			}
		}
	}
	if wholeQueriesAccepted == false && len(queriesMask.Paths) > 0 {
		for _, sourceItem := range source.GetQueries() {
			result.Queries = append(result.Queries, queriesMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 11)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) ProtoMessage() {}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) Subtract(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask {
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask{}
	removedSelectors := make([]bool, 11)
	otherSubMasks := map[NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:   &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask{},
		NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:    &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask{},
		NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:       &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask{},
		NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling: &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask{},
	}
	mySubMasks := map[NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:   &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask{},
		NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:    &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask{},
		NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:       &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask{},
		NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling: &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsgAlertsGroupConditionAlertsAlert_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.(*NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification] = FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask()
					case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo] = FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask()
					case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling] = FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask()
					case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling] = FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlert_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, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert))
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) Project(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert{}
	identificationMask := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask{}
	wholeIdentificationAccepted := false
	violationInfoMask := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask{}
	wholeViolationInfoAccepted := false
	aiHandlingMask := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask{}
	wholeAiHandlingAccepted := false
	operatorHandlingMask := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask{}
	wholeOperatorHandlingAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
				result.Type = source.Type
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
				result.Fqn = source.Fqn
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
				result.DisplayName = source.DisplayName
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
				result.IsFiring = source.IsFiring
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
				result.StartTime = source.StartTime
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
				result.StopTime = source.StopTime
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
				result.Identification = source.Identification
				wholeIdentificationAccepted = true
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
				result.ViolationInfo = source.ViolationInfo
				wholeViolationInfoAccepted = true
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
				result.EscalationLevel = source.EscalationLevel
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
				result.AiHandling = source.AiHandling
				wholeAiHandlingAccepted = true
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
				result.OperatorHandling = source.OperatorHandling
				wholeOperatorHandlingAccepted = true
			}
		case *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
				identificationMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath))
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
				violationInfoMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath))
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
				aiHandlingMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath))
			case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
				operatorHandlingMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath))
			}
		}
	}
	if wholeIdentificationAccepted == false && len(identificationMask.Paths) > 0 {
		result.Identification = identificationMask.Project(source.GetIdentification())
	}
	if wholeViolationInfoAccepted == false && len(violationInfoMask.Paths) > 0 {
		result.ViolationInfo = violationInfoMask.Project(source.GetViolationInfo())
	}
	if wholeAiHandlingAccepted == false && len(aiHandlingMask.Paths) > 0 {
		result.AiHandling = aiHandlingMask.Project(source.GetAiHandling())
	}
	if wholeOperatorHandlingAccepted == false && len(operatorHandlingMask.Paths) > 0 {
		result.OperatorHandling = operatorHandlingMask.Project(source.GetOperatorHandling())
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 3)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) ProtoMessage() {
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) Subtract(other *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask {
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask{}
	removedSelectors := make([]bool, 3)
	otherSubMasks := map[NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation: &monitoring_common.Aggregation_FieldMask{},
	}
	mySubMasks := map[NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation: &monitoring_common.Aggregation_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_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.(*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation] = monitoring_common.FullAggregation_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_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, &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query))
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) Project(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query{}
	aggregationMask := &monitoring_common.Aggregation_FieldMask{}
	wholeAggregationAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
				result.Description = source.Description
			case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
				result.Filter = source.Filter
			case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
				result.Aggregation = source.Aggregation
				wholeAggregationAccepted = true
			}
		case *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
				aggregationMask.AppendPath(tp.subPath.(monitoring_common.Aggregation_FieldPath))
			}
		}
	}
	if wholeAggregationAccepted == false && len(aggregationMask.Paths) > 0 {
		result.Aggregation = aggregationMask.Project(source.GetAggregation())
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 2)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask) ProtoMessage() {
}

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

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

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask))
}

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query))
}

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription:
				result.Description = source.Description
			case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter:
				result.Filter = source.Filter
			}
		}
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 3)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) ProtoMessage() {
}

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

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

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask))
}

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification))
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) Project(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification{}
	var logLabelsMapKeys []string
	wholeLogLabelsAccepted := false
	var metricLabelsMapKeys []string
	wholeMetricLabelsAccepted := false
	var resourceLabelsMapKeys []string
	wholeResourceLabelsAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
				result.LogLabels = source.LogLabels
				wholeLogLabelsAccepted = true
			case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
				result.MetricLabels = source.MetricLabels
				wholeMetricLabelsAccepted = true
			case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
				result.ResourceLabels = source.ResourceLabels
				wholeResourceLabelsAccepted = true
			}
		case *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
				logLabelsMapKeys = append(logLabelsMapKeys, tp.key)
			case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
				metricLabelsMapKeys = append(metricLabelsMapKeys, tp.key)
			case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
				resourceLabelsMapKeys = append(resourceLabelsMapKeys, tp.key)
			}
		}
	}
	if wholeLogLabelsAccepted == false && len(logLabelsMapKeys) > 0 && source.GetLogLabels() != nil {
		copiedMap := map[string]string{}
		sourceMap := source.GetLogLabels()
		for _, key := range logLabelsMapKeys {
			copiedMap[key] = sourceMap[key]
		}
		result.LogLabels = copiedMap
	}
	if wholeMetricLabelsAccepted == false && len(metricLabelsMapKeys) > 0 && source.GetMetricLabels() != nil {
		copiedMap := map[string]string{}
		sourceMap := source.GetMetricLabels()
		for _, key := range metricLabelsMapKeys {
			copiedMap[key] = sourceMap[key]
		}
		result.MetricLabels = copiedMap
	}
	if wholeResourceLabelsAccepted == false && len(resourceLabelsMapKeys) > 0 && source.GetResourceLabels() != nil {
		copiedMap := map[string]string{}
		sourceMap := source.GetResourceLabels()
		for _, key := range resourceLabelsMapKeys {
			copiedMap[key] = sourceMap[key]
		}
		result.ResourceLabels = copiedMap
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 2)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) ProtoMessage() {
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) Subtract(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask {
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries: &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask{},
	}
	mySubMasks := map[NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries: &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_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.(*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries] = FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_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, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo))
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) Project(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo{}
	timeSeriesMask := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask{}
	wholeTimeSeriesAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue:
				result.LogValue = source.LogValue
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
				result.TimeSeries = source.TimeSeries
				wholeTimeSeriesAccepted = true
			}
		case *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
				timeSeriesMask.AppendPath(tp.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath))
			}
		}
	}
	if wholeTimeSeriesAccepted == false && len(timeSeriesMask.Paths) > 0 {
		for _, sourceItem := range source.GetTimeSeries() {
			result.TimeSeries = append(result.TimeSeries, timeSeriesMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 4)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) ProtoMessage() {
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) Subtract(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask {
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask{}
	removedSelectors := make([]bool, 4)
	otherSubMasks := map[NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation: &rcommon.PolicySpec_AIAgentHandling_Remediation_FieldMask{},
	}
	mySubMasks := map[NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation: &rcommon.PolicySpec_AIAgentHandling_Remediation_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_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.(*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation] = rcommon.FullPolicySpec_AIAgentHandling_Remediation_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_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, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling))
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) Project(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling{}
	aiRemediationMask := &rcommon.PolicySpec_AIAgentHandling_Remediation_FieldMask{}
	wholeAiRemediationAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
				result.CurrentState = source.CurrentState
			case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
				result.TroubleshootingNotes = source.TroubleshootingNotes
			case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
				result.AiRemediation = source.AiRemediation
				wholeAiRemediationAccepted = true
			case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
				result.RemediationArg = source.RemediationArg
			}
		case *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
				aiRemediationMask.AppendPath(tp.subPath.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPath))
			}
		}
	}
	if wholeAiRemediationAccepted == false && len(aiRemediationMask.Paths) > 0 {
		result.AiRemediation = aiRemediationMask.Project(source.GetAiRemediation())
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 2)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask) ProtoMessage() {
}

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

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

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
	return fieldMask.Subtract(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask))
}

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling))
}

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
				result.CurrentState = source.CurrentState
			case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
				result.Notes = source.Notes
			}
		}
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling))
}

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

type NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask struct {
	Paths []NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath
}

func FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask {
	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask{}
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold})
	res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter})
	return res
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) IsFull() bool {
	if fieldMask == nil {
		return false
	}
	presentSelectors := make([]bool, 5)
	for _, path := range fieldMask.Paths {
		if asFinal, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath); ok {
			presentSelectors[int(asFinal.selector)] = true
		}
	}
	for _, flag := range presentSelectors {
		if !flag {
			return false
		}
	}
	return true
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) ProtoMessage() {
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) Subtract(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask {
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask{}
	removedSelectors := make([]bool, 5)
	otherSubMasks := map[NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold: &rcommon.AlertingThreshold_FieldMask{},
		NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold: &rcommon.AlertingThreshold_FieldMask{},
	}
	mySubMasks := map[NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector]gotenobject.FieldMask{
		NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold: &rcommon.AlertingThreshold_FieldMask{},
		NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold: &rcommon.AlertingThreshold_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_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.(*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath); ok {
					switch tp.selector {
					case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold] = rcommon.FullAlertingThreshold_FieldMask()
					case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
						mySubMasks[NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold] = rcommon.FullAlertingThreshold_FieldMask()
					}
				} else if tp, ok := path.(*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_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, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) Size() int {
	return proto.Size(fieldMask.ToProtoFieldMask())
}

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) AppendPath(path NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) SetFromCliFlag(raw string) error {
	path, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath(raw)
	if err != nil {
		return err
	}
	fieldMask.Paths = append(fieldMask.Paths, path)
	return nil
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) Set(target, source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) {
	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 *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries), source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries))
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) Project(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries{}
	upperThresholdMask := &rcommon.AlertingThreshold_FieldMask{}
	wholeUpperThresholdAccepted := false
	lowerThresholdMask := &rcommon.AlertingThreshold_FieldMask{}
	wholeLowerThresholdAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
				result.Query = source.Query
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
				result.Values = source.Values
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
				result.UpperThreshold = source.UpperThreshold
				wholeUpperThresholdAccepted = true
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
				result.LowerThreshold = source.LowerThreshold
				wholeLowerThresholdAccepted = true
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
				result.RaisedAfter = source.RaisedAfter
			}
		case *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath:
			switch tp.selector {
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
				upperThresholdMask.AppendPath(tp.subPath.(rcommon.AlertingThreshold_FieldPath))
			case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
				lowerThresholdMask.AppendPath(tp.subPath.(rcommon.AlertingThreshold_FieldPath))
			}
		}
	}
	if wholeUpperThresholdAccepted == false && len(upperThresholdMask.Paths) > 0 {
		result.UpperThreshold = upperThresholdMask.Project(source.GetUpperThreshold())
	}
	if wholeLowerThresholdAccepted == false && len(lowerThresholdMask.Paths) > 0 {
		result.LowerThreshold = lowerThresholdMask.Project(source.GetLowerThreshold())
	}
	return result
}

func (fieldMask *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries))
}

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