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

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

package notification_msg

import (
	"fmt"
	"sort"

	"google.golang.org/protobuf/proto"
	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(fmt.Stringer)
	_ = new(sort.Interface)

	_ = new(proto.Message)
	_ = googlefieldmaskpb.FieldMask{}

	_ = new(gotenobject.FieldPath)
)

// 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{}
)

func (o *NotificationMsg) GotenObjectExt() {}

func (o *NotificationMsg) MakeFullFieldMask() *NotificationMsg_FieldMask {
	return FullNotificationMsg_FieldMask()
}

func (o *NotificationMsg) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_FieldMask()
}

func (o *NotificationMsg) MakeDiffFieldMask(other *NotificationMsg) *NotificationMsg_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_FieldMask()
	}

	res := &NotificationMsg_FieldMask{}
	if o.GetProjectFqn().String() != other.GetProjectFqn().String() {
		res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorProjectFqn})
	}
	if o.GetProjectDisplayName() != other.GetProjectDisplayName() {
		res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorProjectDisplayName})
	}
	if o.GetOrganizationFqn().String() != other.GetOrganizationFqn().String() {
		res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorOrganizationFqn})
	}
	if o.GetOrganizationDisplayName() != other.GetOrganizationDisplayName() {
		res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorOrganizationDisplayName})
	}
	if o.GetPolicyFqn().String() != other.GetPolicyFqn().String() {
		res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorPolicyFqn})
	}
	if o.GetPolicyDisplayName() != other.GetPolicyDisplayName() {
		res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorPolicyDisplayName})
	}
	{
		subMask := o.GetNewFiringAlerts().MakeDiffFieldMask(other.GetNewFiringAlerts())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorNewFiringAlerts})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorNewFiringAlerts, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetAlertsEscalatedByAiToOperator().MakeDiffFieldMask(other.GetAlertsEscalatedByAiToOperator())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetAlertsAwaitingForApprovalWithAiRemediation().MakeDiffFieldMask(other.GetAlertsAwaitingForApprovalWithAiRemediation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetAlertsFlaggedToIgnoreByAi().MakeDiffFieldMask(other.GetAlertsFlaggedToIgnoreByAi())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetAlertsWithConditionMarkedForAdjustingByAi().MakeDiffFieldMask(other.GetAlertsWithConditionMarkedForAdjustingByAi())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetAlertsWithAiRemediationApplied().MakeDiffFieldMask(other.GetAlertsWithAiRemediationApplied())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetAlertsWithOperatorRemediationApplied().MakeDiffFieldMask(other.GetAlertsWithOperatorRemediationApplied())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetStoppedAlerts().MakeDiffFieldMask(other.GetStoppedAlerts())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorStoppedAlerts})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorStoppedAlerts, subPath: subpath})
			}
		}
	}
	return res
}

func (o *NotificationMsg) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg))
}

func (o *NotificationMsg) Clone() *NotificationMsg {
	if o == nil {
		return nil
	}
	result := &NotificationMsg{}
	if o.ProjectFqn == nil {
		result.ProjectFqn = nil
	} else if data, err := o.ProjectFqn.ProtoString(); err != nil {
		panic(err)
	} else {
		result.ProjectFqn = &iam_project.Name{}
		if err := result.ProjectFqn.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.ProjectDisplayName = o.ProjectDisplayName
	if o.OrganizationFqn == nil {
		result.OrganizationFqn = nil
	} else if data, err := o.OrganizationFqn.ProtoString(); err != nil {
		panic(err)
	} else {
		result.OrganizationFqn = &iam_organization.Name{}
		if err := result.OrganizationFqn.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.OrganizationDisplayName = o.OrganizationDisplayName
	if o.PolicyFqn == nil {
		result.PolicyFqn = nil
	} else if data, err := o.PolicyFqn.ProtoString(); err != nil {
		panic(err)
	} else {
		result.PolicyFqn = &policy.Name{}
		if err := result.PolicyFqn.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.PolicyDisplayName = o.PolicyDisplayName
	result.NewFiringAlerts = o.NewFiringAlerts.Clone()
	result.AlertsEscalatedByAiToOperator = o.AlertsEscalatedByAiToOperator.Clone()
	result.AlertsAwaitingForApprovalWithAiRemediation = o.AlertsAwaitingForApprovalWithAiRemediation.Clone()
	result.AlertsFlaggedToIgnoreByAi = o.AlertsFlaggedToIgnoreByAi.Clone()
	result.AlertsWithConditionMarkedForAdjustingByAi = o.AlertsWithConditionMarkedForAdjustingByAi.Clone()
	result.AlertsWithAiRemediationApplied = o.AlertsWithAiRemediationApplied.Clone()
	result.AlertsWithOperatorRemediationApplied = o.AlertsWithOperatorRemediationApplied.Clone()
	result.StoppedAlerts = o.StoppedAlerts.Clone()
	return result
}

func (o *NotificationMsg) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg) Merge(source *NotificationMsg) {
	if source.GetProjectFqn() != nil {
		if data, err := source.GetProjectFqn().ProtoString(); err != nil {
			panic(err)
		} else {
			o.ProjectFqn = &iam_project.Name{}
			if err := o.ProjectFqn.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.ProjectFqn = nil
	}
	o.ProjectDisplayName = source.GetProjectDisplayName()
	if source.GetOrganizationFqn() != nil {
		if data, err := source.GetOrganizationFqn().ProtoString(); err != nil {
			panic(err)
		} else {
			o.OrganizationFqn = &iam_organization.Name{}
			if err := o.OrganizationFqn.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.OrganizationFqn = nil
	}
	o.OrganizationDisplayName = source.GetOrganizationDisplayName()
	if source.GetPolicyFqn() != nil {
		if data, err := source.GetPolicyFqn().ProtoString(); err != nil {
			panic(err)
		} else {
			o.PolicyFqn = &policy.Name{}
			if err := o.PolicyFqn.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.PolicyFqn = nil
	}
	o.PolicyDisplayName = source.GetPolicyDisplayName()
	if source.GetNewFiringAlerts() != nil {
		if o.NewFiringAlerts == nil {
			o.NewFiringAlerts = new(NotificationMsg_AlertsGroup)
		}
		o.NewFiringAlerts.Merge(source.GetNewFiringAlerts())
	}
	if source.GetAlertsEscalatedByAiToOperator() != nil {
		if o.AlertsEscalatedByAiToOperator == nil {
			o.AlertsEscalatedByAiToOperator = new(NotificationMsg_AlertsGroup)
		}
		o.AlertsEscalatedByAiToOperator.Merge(source.GetAlertsEscalatedByAiToOperator())
	}
	if source.GetAlertsAwaitingForApprovalWithAiRemediation() != nil {
		if o.AlertsAwaitingForApprovalWithAiRemediation == nil {
			o.AlertsAwaitingForApprovalWithAiRemediation = new(NotificationMsg_AlertsGroup)
		}
		o.AlertsAwaitingForApprovalWithAiRemediation.Merge(source.GetAlertsAwaitingForApprovalWithAiRemediation())
	}
	if source.GetAlertsFlaggedToIgnoreByAi() != nil {
		if o.AlertsFlaggedToIgnoreByAi == nil {
			o.AlertsFlaggedToIgnoreByAi = new(NotificationMsg_AlertsGroup)
		}
		o.AlertsFlaggedToIgnoreByAi.Merge(source.GetAlertsFlaggedToIgnoreByAi())
	}
	if source.GetAlertsWithConditionMarkedForAdjustingByAi() != nil {
		if o.AlertsWithConditionMarkedForAdjustingByAi == nil {
			o.AlertsWithConditionMarkedForAdjustingByAi = new(NotificationMsg_AlertsGroup)
		}
		o.AlertsWithConditionMarkedForAdjustingByAi.Merge(source.GetAlertsWithConditionMarkedForAdjustingByAi())
	}
	if source.GetAlertsWithAiRemediationApplied() != nil {
		if o.AlertsWithAiRemediationApplied == nil {
			o.AlertsWithAiRemediationApplied = new(NotificationMsg_AlertsGroup)
		}
		o.AlertsWithAiRemediationApplied.Merge(source.GetAlertsWithAiRemediationApplied())
	}
	if source.GetAlertsWithOperatorRemediationApplied() != nil {
		if o.AlertsWithOperatorRemediationApplied == nil {
			o.AlertsWithOperatorRemediationApplied = new(NotificationMsg_AlertsGroup)
		}
		o.AlertsWithOperatorRemediationApplied.Merge(source.GetAlertsWithOperatorRemediationApplied())
	}
	if source.GetStoppedAlerts() != nil {
		if o.StoppedAlerts == nil {
			o.StoppedAlerts = new(NotificationMsg_AlertsGroup)
		}
		o.StoppedAlerts.Merge(source.GetStoppedAlerts())
	}
}

func (o *NotificationMsg) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg))
}

func (o *NotificationMsg_AlertsGroup) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup) MakeFullFieldMask() *NotificationMsg_AlertsGroup_FieldMask {
	return FullNotificationMsg_AlertsGroup_FieldMask()
}

func (o *NotificationMsg_AlertsGroup) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_FieldMask()
}

func (o *NotificationMsg_AlertsGroup) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup) *NotificationMsg_AlertsGroup_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_FieldMask{}

	if len(o.GetByCondition()) == len(other.GetByCondition()) {
		for i, lValue := range o.GetByCondition() {
			rValue := other.GetByCondition()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroup_FieldTerminalPath{selector: NotificationMsgAlertsGroup_FieldPathSelectorByCondition})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroup_FieldTerminalPath{selector: NotificationMsgAlertsGroup_FieldPathSelectorByCondition})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup))
}

func (o *NotificationMsg_AlertsGroup) Clone() *NotificationMsg_AlertsGroup {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup{}
	result.ByCondition = make([]*NotificationMsg_AlertsGroup_ConditionAlerts, len(o.ByCondition))
	for i, sourceValue := range o.ByCondition {
		result.ByCondition[i] = sourceValue.Clone()
	}
	return result
}

func (o *NotificationMsg_AlertsGroup) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup) Merge(source *NotificationMsg_AlertsGroup) {
	for _, sourceValue := range source.GetByCondition() {
		exists := false
		for _, currentValue := range o.ByCondition {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *NotificationMsg_AlertsGroup_ConditionAlerts
			if sourceValue != nil {
				newDstElement = new(NotificationMsg_AlertsGroup_ConditionAlerts)
				newDstElement.Merge(sourceValue)
			}
			o.ByCondition = append(o.ByCondition, newDstElement)
		}
	}

}

func (o *NotificationMsg_AlertsGroup) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts) *NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_FieldMask{}
	{
		_, leftSelected := o.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition)
		_, rightSelected := other.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition)
		if leftSelected == rightSelected {
			subMask := o.GetTimeSeriesCondition().MakeDiffFieldMask(other.GetTimeSeriesCondition())
			if subMask.IsFull() {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition})
			} else {
				for _, subpath := range subMask.Paths {
					res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition, subPath: subpath})
				}
			}
		} else {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition})
		}
	}
	{
		_, leftSelected := o.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition)
		_, rightSelected := other.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition)
		if leftSelected == rightSelected {
			subMask := o.GetLogCondition().MakeDiffFieldMask(other.GetLogCondition())
			if subMask.IsFull() {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition})
			} else {
				for _, subpath := range subMask.Paths {
					res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition, subPath: subpath})
				}
			}
		} else {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition})
		}
	}

	if len(o.GetAlerts()) == len(other.GetAlerts()) {
		for i, lValue := range o.GetAlerts() {
			rValue := other.GetAlerts()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts})
	}
	if o.GetMoreAlertsCount() != other.GetMoreAlertsCount() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts{}
	if o, ok := o.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); ok {
		result.Type = (*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition)(nil)
		if o != nil {
			result.Type = &NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition{}
			result := result.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition)
			result.TimeSeriesCondition = o.TimeSeriesCondition.Clone()
		}
	}
	if o, ok := o.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); ok {
		result.Type = (*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition)(nil)
		if o != nil {
			result.Type = &NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition{}
			result := result.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition)
			result.LogCondition = o.LogCondition.Clone()
		}
	}
	result.Alerts = make([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert, len(o.Alerts))
	for i, sourceValue := range o.Alerts {
		result.Alerts[i] = sourceValue.Clone()
	}
	result.MoreAlertsCount = o.MoreAlertsCount
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts) {
	if source, ok := source.GetType().(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); ok {
		if dstOneOf, ok := o.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); !ok || dstOneOf == nil {
			o.Type = &NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition{}
		}
		if source != nil {
			o := o.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition)
			if source.TimeSeriesCondition != nil {
				if o.TimeSeriesCondition == nil {
					o.TimeSeriesCondition = new(NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType)
				}
				o.TimeSeriesCondition.Merge(source.TimeSeriesCondition)
			}
		}
	}
	if source, ok := source.GetType().(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); ok {
		if dstOneOf, ok := o.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); !ok || dstOneOf == nil {
			o.Type = &NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition{}
		}
		if source != nil {
			o := o.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition)
			if source.LogCondition != nil {
				if o.LogCondition == nil {
					o.LogCondition = new(NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType)
				}
				o.LogCondition.Merge(source.LogCondition)
			}
		}
	}
	for _, sourceValue := range source.GetAlerts() {
		exists := false
		for _, currentValue := range o.Alerts {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *NotificationMsg_AlertsGroup_ConditionAlerts_Alert
			if sourceValue != nil {
				newDstElement = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert)
				newDstElement.Merge(sourceValue)
			}
			o.Alerts = append(o.Alerts, newDstElement)
		}
	}

	o.MoreAlertsCount = source.GetMoreAlertsCount()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_FieldMask{}
	if o.GetFqn().String() != other.GetFqn().String() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn})
	}
	if o.GetDisplayName() != other.GetDisplayName() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName})
	}

	if len(o.GetQueries()) == len(other.GetQueries()) {
		for i, lValue := range o.GetQueries() {
			rValue := other.GetQueries()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType{}
	if o.Fqn == nil {
		result.Fqn = nil
	} else if data, err := o.Fqn.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Fqn = &ts_condition.Name{}
		if err := result.Fqn.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.DisplayName = o.DisplayName
	result.Queries = make([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query, len(o.Queries))
	for i, sourceValue := range o.Queries {
		result.Queries[i] = sourceValue.Clone()
	}
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) {
	if source.GetFqn() != nil {
		if data, err := source.GetFqn().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Fqn = &ts_condition.Name{}
			if err := o.Fqn.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Fqn = nil
	}
	o.DisplayName = source.GetDisplayName()
	for _, sourceValue := range source.GetQueries() {
		exists := false
		for _, currentValue := range o.Queries {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query
			if sourceValue != nil {
				newDstElement = new(NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)
				newDstElement.Merge(sourceValue)
			}
			o.Queries = append(o.Queries, newDstElement)
		}
	}

}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_FieldMask{}
	if o.GetFqn().String() != other.GetFqn().String() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn})
	}
	if o.GetDisplayName() != other.GetDisplayName() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName})
	}

	if len(o.GetQueries()) == len(other.GetQueries()) {
		for i, lValue := range o.GetQueries() {
			rValue := other.GetQueries()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType{}
	if o.Fqn == nil {
		result.Fqn = nil
	} else if data, err := o.Fqn.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Fqn = &log_condition.Name{}
		if err := result.Fqn.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.DisplayName = o.DisplayName
	result.Queries = make([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query, len(o.Queries))
	for i, sourceValue := range o.Queries {
		result.Queries[i] = sourceValue.Clone()
	}
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) {
	if source.GetFqn() != nil {
		if data, err := source.GetFqn().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Fqn = &log_condition.Name{}
			if err := o.Fqn.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Fqn = nil
	}
	o.DisplayName = source.GetDisplayName()
	for _, sourceValue := range source.GetQueries() {
		exists := false
		for _, currentValue := range o.Queries {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query
			if sourceValue != nil {
				newDstElement = new(NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)
				newDstElement.Merge(sourceValue)
			}
			o.Queries = append(o.Queries, newDstElement)
		}
	}

}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_FieldMask{}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType})
	}
	if o.GetFqn().String() != other.GetFqn().String() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn})
	}
	if o.GetDisplayName() != other.GetDisplayName() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName})
	}
	if o.GetIsFiring() != other.GetIsFiring() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring})
	}
	if !proto.Equal(o.GetStartTime(), other.GetStartTime()) {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime})
	}
	if !proto.Equal(o.GetStopTime(), other.GetStopTime()) {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime})
	}
	{
		subMask := o.GetIdentification().MakeDiffFieldMask(other.GetIdentification())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetViolationInfo().MakeDiffFieldMask(other.GetViolationInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo, subPath: subpath})
			}
		}
	}
	if o.GetEscalationLevel() != other.GetEscalationLevel() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel})
	}
	{
		subMask := o.GetAiHandling().MakeDiffFieldMask(other.GetAiHandling())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetOperatorHandling().MakeDiffFieldMask(other.GetOperatorHandling())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling, subPath: subpath})
			}
		}
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert{}
	result.Type = o.Type
	if o.Fqn == nil {
		result.Fqn = nil
	} else if data, err := o.Fqn.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Fqn = &alert.Name{}
		if err := result.Fqn.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.DisplayName = o.DisplayName
	result.IsFiring = o.IsFiring
	result.StartTime = proto.Clone(o.StartTime).(*timestamppb.Timestamp)
	result.StopTime = proto.Clone(o.StopTime).(*timestamppb.Timestamp)
	result.Identification = o.Identification.Clone()
	result.ViolationInfo = o.ViolationInfo.Clone()
	result.EscalationLevel = o.EscalationLevel
	result.AiHandling = o.AiHandling.Clone()
	result.OperatorHandling = o.OperatorHandling.Clone()
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) {
	o.Type = source.GetType()
	if source.GetFqn() != nil {
		if data, err := source.GetFqn().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Fqn = &alert.Name{}
			if err := o.Fqn.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Fqn = nil
	}
	o.DisplayName = source.GetDisplayName()
	o.IsFiring = source.GetIsFiring()
	if source.GetStartTime() != nil {
		if o.StartTime == nil {
			o.StartTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.StartTime, source.GetStartTime())
	}
	if source.GetStopTime() != nil {
		if o.StopTime == nil {
			o.StopTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.StopTime, source.GetStopTime())
	}
	if source.GetIdentification() != nil {
		if o.Identification == nil {
			o.Identification = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)
		}
		o.Identification.Merge(source.GetIdentification())
	}
	if source.GetViolationInfo() != nil {
		if o.ViolationInfo == nil {
			o.ViolationInfo = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo)
		}
		o.ViolationInfo.Merge(source.GetViolationInfo())
	}
	o.EscalationLevel = source.GetEscalationLevel()
	if source.GetAiHandling() != nil {
		if o.AiHandling == nil {
			o.AiHandling = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)
		}
		o.AiHandling.Merge(source.GetAiHandling())
	}
	if source.GetOperatorHandling() != nil {
		if o.OperatorHandling == nil {
			o.OperatorHandling = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling)
		}
		o.OperatorHandling.Merge(source.GetOperatorHandling())
	}
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query_FieldMask{}
	if o.GetDescription() != other.GetDescription() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription})
	}
	if o.GetFilter() != other.GetFilter() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter})
	}
	{
		subMask := o.GetAggregation().MakeDiffFieldMask(other.GetAggregation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation, subPath: subpath})
			}
		}
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query{}
	result.Description = o.Description
	result.Filter = o.Filter
	result.Aggregation = o.Aggregation.Clone()
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) {
	o.Description = source.GetDescription()
	o.Filter = source.GetFilter()
	if source.GetAggregation() != nil {
		if o.Aggregation == nil {
			o.Aggregation = new(monitoring_common.Aggregation)
		}
		o.Aggregation.Merge(source.GetAggregation())
	}
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query_FieldMask{}
	if o.GetDescription() != other.GetDescription() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription})
	}
	if o.GetFilter() != other.GetFilter() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query{}
	result.Description = o.Description
	result.Filter = o.Filter
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) {
	o.Description = source.GetDescription()
	o.Filter = source.GetFilter()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification_FieldMask{}

	if len(o.GetLogLabels()) == len(other.GetLogLabels()) {
		for i, lValue := range o.GetLogLabels() {
			rValue := other.GetLogLabels()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels})
	}

	if len(o.GetMetricLabels()) == len(other.GetMetricLabels()) {
		for i, lValue := range o.GetMetricLabels() {
			rValue := other.GetMetricLabels()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels})
	}

	if len(o.GetResourceLabels()) == len(other.GetResourceLabels()) {
		for i, lValue := range o.GetResourceLabels() {
			rValue := other.GetResourceLabels()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification{}
	result.LogLabels = map[string]string{}
	for key, sourceValue := range o.LogLabels {
		result.LogLabels[key] = sourceValue
	}
	result.MetricLabels = map[string]string{}
	for key, sourceValue := range o.MetricLabels {
		result.MetricLabels[key] = sourceValue
	}
	result.ResourceLabels = map[string]string{}
	for key, sourceValue := range o.ResourceLabels {
		result.ResourceLabels[key] = sourceValue
	}
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) {
	if source.GetLogLabels() != nil {
		if o.LogLabels == nil {
			o.LogLabels = make(map[string]string, len(source.GetLogLabels()))
		}
		for key, sourceValue := range source.GetLogLabels() {
			o.LogLabels[key] = sourceValue
		}
	}
	if source.GetMetricLabels() != nil {
		if o.MetricLabels == nil {
			o.MetricLabels = make(map[string]string, len(source.GetMetricLabels()))
		}
		for key, sourceValue := range source.GetMetricLabels() {
			o.MetricLabels[key] = sourceValue
		}
	}
	if source.GetResourceLabels() != nil {
		if o.ResourceLabels == nil {
			o.ResourceLabels = make(map[string]string, len(source.GetResourceLabels()))
		}
		for key, sourceValue := range source.GetResourceLabels() {
			o.ResourceLabels[key] = sourceValue
		}
	}
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_FieldMask{}
	if o.GetLogValue() != other.GetLogValue() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue})
	}

	if len(o.GetTimeSeries()) == len(other.GetTimeSeries()) {
		for i, lValue := range o.GetTimeSeries() {
			rValue := other.GetTimeSeries()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo{}
	result.LogValue = o.LogValue
	result.TimeSeries = make([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries, len(o.TimeSeries))
	for i, sourceValue := range o.TimeSeries {
		result.TimeSeries[i] = sourceValue.Clone()
	}
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) {
	o.LogValue = source.GetLogValue()
	for _, sourceValue := range source.GetTimeSeries() {
		exists := false
		for _, currentValue := range o.TimeSeries {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries
			if sourceValue != nil {
				newDstElement = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)
				newDstElement.Merge(sourceValue)
			}
			o.TimeSeries = append(o.TimeSeries, newDstElement)
		}
	}

}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling_FieldMask{}
	if o.GetCurrentState() != other.GetCurrentState() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState})
	}
	if o.GetTroubleshootingNotes() != other.GetTroubleshootingNotes() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes})
	}
	{
		subMask := o.GetAiRemediation().MakeDiffFieldMask(other.GetAiRemediation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation, subPath: subpath})
			}
		}
	}
	if o.GetRemediationArg() != other.GetRemediationArg() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling{}
	result.CurrentState = o.CurrentState
	result.TroubleshootingNotes = o.TroubleshootingNotes
	result.AiRemediation = o.AiRemediation.Clone()
	result.RemediationArg = o.RemediationArg
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) {
	o.CurrentState = source.GetCurrentState()
	o.TroubleshootingNotes = source.GetTroubleshootingNotes()
	if source.GetAiRemediation() != nil {
		if o.AiRemediation == nil {
			o.AiRemediation = new(rcommon.PolicySpec_AIAgentHandling_Remediation)
		}
		o.AiRemediation.Merge(source.GetAiRemediation())
	}
	o.RemediationArg = source.GetRemediationArg()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) GotenObjectExt() {}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling_FieldMask{}
	if o.GetCurrentState() != other.GetCurrentState() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState})
	}
	if o.GetNotes() != other.GetNotes() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling{}
	result.CurrentState = o.CurrentState
	result.Notes = o.Notes
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) {
	o.CurrentState = source.GetCurrentState()
	o.Notes = source.GetNotes()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) GotenObjectExt() {
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) MakeFullFieldMask() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) MakeDiffFieldMask(other *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask {
	if o == nil && other == nil {
		return &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask{}
	}
	if o == nil || other == nil {
		return FullNotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask()
	}

	res := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries_FieldMask{}
	if o.GetQuery() != other.GetQuery() {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery})
	}

	if len(o.GetValues()) == len(other.GetValues()) {
		for i, lValue := range o.GetValues() {
			rValue := other.GetValues()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues})
	}
	{
		subMask := o.GetUpperThreshold().MakeDiffFieldMask(other.GetUpperThreshold())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetLowerThreshold().MakeDiffFieldMask(other.GetLowerThreshold())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold, subPath: subpath})
			}
		}
	}
	if !proto.Equal(o.GetRaisedAfter(), other.GetRaisedAfter()) {
		res.Paths = append(res.Paths, &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter})
	}
	return res
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries))
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) Clone() *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries {
	if o == nil {
		return nil
	}
	result := &NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries{}
	result.Query = o.Query
	result.Values = make([]float64, len(o.Values))
	for i, sourceValue := range o.Values {
		result.Values[i] = sourceValue
	}
	result.UpperThreshold = o.UpperThreshold.Clone()
	result.LowerThreshold = o.LowerThreshold.Clone()
	result.RaisedAfter = proto.Clone(o.RaisedAfter).(*durationpb.Duration)
	return result
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) Merge(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) {
	o.Query = source.GetQuery()
	for _, sourceValue := range source.GetValues() {
		exists := false
		for _, currentValue := range o.Values {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement float64
			newDstElement = sourceValue
			o.Values = append(o.Values, newDstElement)
		}
	}

	if source.GetUpperThreshold() != nil {
		if o.UpperThreshold == nil {
			o.UpperThreshold = new(rcommon.AlertingThreshold)
		}
		o.UpperThreshold.Merge(source.GetUpperThreshold())
	}
	if source.GetLowerThreshold() != nil {
		if o.LowerThreshold == nil {
			o.LowerThreshold = new(rcommon.AlertingThreshold)
		}
		o.LowerThreshold.Merge(source.GetLowerThreshold())
	}
	if source.GetRaisedAfter() != nil {
		if o.RaisedAfter == nil {
			o.RaisedAfter = new(durationpb.Duration)
		}
		proto.Merge(o.RaisedAfter, source.GetRaisedAfter())
	}
}

func (o *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries))
}