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

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

package alert

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 (
	rcommon "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/common"
	log_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/log_condition"
	notification_channel "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/notification_channel"
	ts_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/ts_condition"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	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 (
	_ = &log_condition.LogCondition{}
	_ = &notification_channel.NotificationChannel{}
	_ = &rcommon.LogCndSpec{}
	_ = &ts_condition.TsCondition{}
	_ = &durationpb.Duration{}
	_ = &timestamppb.Timestamp{}
	_ = &meta.Meta{}
)

func (o *Alert) GotenObjectExt() {}

func (o *Alert) MakeFullFieldMask() *Alert_FieldMask {
	return FullAlert_FieldMask()
}

func (o *Alert) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullAlert_FieldMask()
}

func (o *Alert) MakeDiffFieldMask(other *Alert) *Alert_FieldMask {
	if o == nil && other == nil {
		return &Alert_FieldMask{}
	}
	if o == nil || other == nil {
		return FullAlert_FieldMask()
	}

	res := &Alert_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorName})
	}
	{
		subMask := o.GetMetadata().MakeDiffFieldMask(other.GetMetadata())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorMetadata})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Alert_FieldSubPath{selector: Alert_FieldPathSelectorMetadata, subPath: subpath})
			}
		}
	}
	if o.GetDisplayName() != other.GetDisplayName() {
		res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorDisplayName})
	}
	{
		subMask := o.GetAlertingResource().MakeDiffFieldMask(other.GetAlertingResource())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorAlertingResource})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Alert_FieldSubPath{selector: Alert_FieldPathSelectorAlertingResource, subPath: subpath})
			}
		}
	}
	{
		_, leftSelected := o.Info.(*Alert_TsInfo_)
		_, rightSelected := other.Info.(*Alert_TsInfo_)
		if leftSelected == rightSelected {
			subMask := o.GetTsInfo().MakeDiffFieldMask(other.GetTsInfo())
			if subMask.IsFull() {
				res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorTsInfo})
			} else {
				for _, subpath := range subMask.Paths {
					res.Paths = append(res.Paths, &Alert_FieldSubPath{selector: Alert_FieldPathSelectorTsInfo, subPath: subpath})
				}
			}
		} else {
			res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorTsInfo})
		}
	}
	{
		_, leftSelected := o.Info.(*Alert_LogInfo_)
		_, rightSelected := other.Info.(*Alert_LogInfo_)
		if leftSelected == rightSelected {
			subMask := o.GetLogInfo().MakeDiffFieldMask(other.GetLogInfo())
			if subMask.IsFull() {
				res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorLogInfo})
			} else {
				for _, subpath := range subMask.Paths {
					res.Paths = append(res.Paths, &Alert_FieldSubPath{selector: Alert_FieldPathSelectorLogInfo, subPath: subpath})
				}
			}
		} else {
			res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorLogInfo})
		}
	}
	{
		subMask := o.GetState().MakeDiffFieldMask(other.GetState())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorState})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Alert_FieldSubPath{selector: Alert_FieldPathSelectorState, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetInternal().MakeDiffFieldMask(other.GetInternal())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorInternal})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Alert_FieldSubPath{selector: Alert_FieldPathSelectorInternal, subPath: subpath})
			}
		}
	}
	return res
}

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

func (o *Alert) Clone() *Alert {
	if o == nil {
		return nil
	}
	result := &Alert{}
	if o.Name == nil {
		result.Name = nil
	} else if data, err := o.Name.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Name = &Name{}
		if err := result.Name.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.Metadata = o.Metadata.Clone()
	result.DisplayName = o.DisplayName
	result.AlertingResource = o.AlertingResource.Clone()
	if o, ok := o.Info.(*Alert_TsInfo_); ok {
		result.Info = (*Alert_TsInfo_)(nil)
		if o != nil {
			result.Info = &Alert_TsInfo_{}
			result := result.Info.(*Alert_TsInfo_)
			result.TsInfo = o.TsInfo.Clone()
		}
	}
	if o, ok := o.Info.(*Alert_LogInfo_); ok {
		result.Info = (*Alert_LogInfo_)(nil)
		if o != nil {
			result.Info = &Alert_LogInfo_{}
			result := result.Info.(*Alert_LogInfo_)
			result.LogInfo = o.LogInfo.Clone()
		}
	}
	result.State = o.State.Clone()
	result.Internal = o.Internal.Clone()
	return result
}

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

func (o *Alert) Merge(source *Alert) {
	if source.GetName() != nil {
		if data, err := source.GetName().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Name = &Name{}
			if err := o.Name.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Name = nil
	}
	if source.GetMetadata() != nil {
		if o.Metadata == nil {
			o.Metadata = new(meta.Meta)
		}
		o.Metadata.Merge(source.GetMetadata())
	}
	o.DisplayName = source.GetDisplayName()
	if source.GetAlertingResource() != nil {
		if o.AlertingResource == nil {
			o.AlertingResource = new(meta.OwnerReference)
		}
		o.AlertingResource.Merge(source.GetAlertingResource())
	}
	if source, ok := source.GetInfo().(*Alert_TsInfo_); ok {
		if dstOneOf, ok := o.Info.(*Alert_TsInfo_); !ok || dstOneOf == nil {
			o.Info = &Alert_TsInfo_{}
		}
		if source != nil {
			o := o.Info.(*Alert_TsInfo_)
			if source.TsInfo != nil {
				if o.TsInfo == nil {
					o.TsInfo = new(Alert_TsInfo)
				}
				o.TsInfo.Merge(source.TsInfo)
			}
		}
	}
	if source, ok := source.GetInfo().(*Alert_LogInfo_); ok {
		if dstOneOf, ok := o.Info.(*Alert_LogInfo_); !ok || dstOneOf == nil {
			o.Info = &Alert_LogInfo_{}
		}
		if source != nil {
			o := o.Info.(*Alert_LogInfo_)
			if source.LogInfo != nil {
				if o.LogInfo == nil {
					o.LogInfo = new(Alert_LogInfo)
				}
				o.LogInfo.Merge(source.LogInfo)
			}
		}
	}
	if source.GetState() != nil {
		if o.State == nil {
			o.State = new(Alert_State)
		}
		o.State.Merge(source.GetState())
	}
	if source.GetInternal() != nil {
		if o.Internal == nil {
			o.Internal = new(Alert_Internal)
		}
		o.Internal.Merge(source.GetInternal())
	}
}

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

func (o *Alert_TsInfo) GotenObjectExt() {}

func (o *Alert_TsInfo) MakeFullFieldMask() *Alert_TsInfo_FieldMask {
	return FullAlert_TsInfo_FieldMask()
}

func (o *Alert_TsInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullAlert_TsInfo_FieldMask()
}

func (o *Alert_TsInfo) MakeDiffFieldMask(other *Alert_TsInfo) *Alert_TsInfo_FieldMask {
	if o == nil && other == nil {
		return &Alert_TsInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullAlert_TsInfo_FieldMask()
	}

	res := &Alert_TsInfo_FieldMask{}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorType})
	}
	if !proto.Equal(o.GetAnomalyWindowSize(), other.GetAnomalyWindowSize()) {
		res.Paths = append(res.Paths, &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorAnomalyWindowSize})
	}
	if string(o.GetCommonKey()) != string(other.GetCommonKey()) {
		res.Paths = append(res.Paths, &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorCommonKey})
	}

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

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

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

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

	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, &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorTimeSeries})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorTimeSeries})
	}
	return res
}

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

func (o *Alert_TsInfo) Clone() *Alert_TsInfo {
	if o == nil {
		return nil
	}
	result := &Alert_TsInfo{}
	result.Type = o.Type
	result.AnomalyWindowSize = proto.Clone(o.AnomalyWindowSize).(*durationpb.Duration)
	result.CommonKey = make([]byte, len(o.CommonKey))
	for i, bt := range o.CommonKey {
		result.CommonKey[i] = bt
	}
	result.MetricTypes = make([]string, len(o.MetricTypes))
	for i, sourceValue := range o.MetricTypes {
		result.MetricTypes[i] = sourceValue
	}
	result.ResourceTypes = make([]string, len(o.ResourceTypes))
	for i, sourceValue := range o.ResourceTypes {
		result.ResourceTypes[i] = sourceValue
	}
	result.CommonMetricLabels = map[string]string{}
	for key, sourceValue := range o.CommonMetricLabels {
		result.CommonMetricLabels[key] = sourceValue
	}
	result.CommonResourceLabels = map[string]string{}
	for key, sourceValue := range o.CommonResourceLabels {
		result.CommonResourceLabels[key] = sourceValue
	}
	result.TimeSeries = make([]*Alert_TsInfo_TimeSeries, len(o.TimeSeries))
	for i, sourceValue := range o.TimeSeries {
		result.TimeSeries[i] = sourceValue.Clone()
	}
	return result
}

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

func (o *Alert_TsInfo) Merge(source *Alert_TsInfo) {
	o.Type = source.GetType()
	if source.GetAnomalyWindowSize() != nil {
		if o.AnomalyWindowSize == nil {
			o.AnomalyWindowSize = new(durationpb.Duration)
		}
		proto.Merge(o.AnomalyWindowSize, source.GetAnomalyWindowSize())
	}
	o.CommonKey = make([]byte, len(source.GetCommonKey()))
	for i, bt := range source.GetCommonKey() {
		o.CommonKey[i] = bt
	}
	for _, sourceValue := range source.GetMetricTypes() {
		exists := false
		for _, currentValue := range o.MetricTypes {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.MetricTypes = append(o.MetricTypes, newDstElement)
		}
	}

	for _, sourceValue := range source.GetResourceTypes() {
		exists := false
		for _, currentValue := range o.ResourceTypes {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.ResourceTypes = append(o.ResourceTypes, newDstElement)
		}
	}

	if source.GetCommonMetricLabels() != nil {
		if o.CommonMetricLabels == nil {
			o.CommonMetricLabels = make(map[string]string, len(source.GetCommonMetricLabels()))
		}
		for key, sourceValue := range source.GetCommonMetricLabels() {
			o.CommonMetricLabels[key] = sourceValue
		}
	}
	if source.GetCommonResourceLabels() != nil {
		if o.CommonResourceLabels == nil {
			o.CommonResourceLabels = make(map[string]string, len(source.GetCommonResourceLabels()))
		}
		for key, sourceValue := range source.GetCommonResourceLabels() {
			o.CommonResourceLabels[key] = sourceValue
		}
	}
	for _, sourceValue := range source.GetTimeSeries() {
		exists := false
		for _, currentValue := range o.TimeSeries {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Alert_TsInfo_TimeSeries
			if sourceValue != nil {
				newDstElement = new(Alert_TsInfo_TimeSeries)
				newDstElement.Merge(sourceValue)
			}
			o.TimeSeries = append(o.TimeSeries, newDstElement)
		}
	}

}

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

func (o *Alert_LogInfo) GotenObjectExt() {}

func (o *Alert_LogInfo) MakeFullFieldMask() *Alert_LogInfo_FieldMask {
	return FullAlert_LogInfo_FieldMask()
}

func (o *Alert_LogInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullAlert_LogInfo_FieldMask()
}

func (o *Alert_LogInfo) MakeDiffFieldMask(other *Alert_LogInfo) *Alert_LogInfo_FieldMask {
	if o == nil && other == nil {
		return &Alert_LogInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullAlert_LogInfo_FieldMask()
	}

	res := &Alert_LogInfo_FieldMask{}
	if string(o.GetCommonKey()) != string(other.GetCommonKey()) {
		res.Paths = append(res.Paths, &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorCommonKey})
	}

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

	if len(o.GetCommonLogLabels()) == len(other.GetCommonLogLabels()) {
		for i, lValue := range o.GetCommonLogLabels() {
			rValue := other.GetCommonLogLabels()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorCommonLogLabels})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorCommonLogLabels})
	}
	if o.GetViolatingLog() != other.GetViolatingLog() {
		res.Paths = append(res.Paths, &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorViolatingLog})
	}
	return res
}

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

func (o *Alert_LogInfo) Clone() *Alert_LogInfo {
	if o == nil {
		return nil
	}
	result := &Alert_LogInfo{}
	result.CommonKey = make([]byte, len(o.CommonKey))
	for i, bt := range o.CommonKey {
		result.CommonKey[i] = bt
	}
	result.LogTypes = make([]string, len(o.LogTypes))
	for i, sourceValue := range o.LogTypes {
		result.LogTypes[i] = sourceValue
	}
	result.CommonLogLabels = map[string]string{}
	for key, sourceValue := range o.CommonLogLabels {
		result.CommonLogLabels[key] = sourceValue
	}
	result.ViolatingLog = o.ViolatingLog
	return result
}

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

func (o *Alert_LogInfo) Merge(source *Alert_LogInfo) {
	o.CommonKey = make([]byte, len(source.GetCommonKey()))
	for i, bt := range source.GetCommonKey() {
		o.CommonKey[i] = bt
	}
	for _, sourceValue := range source.GetLogTypes() {
		exists := false
		for _, currentValue := range o.LogTypes {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.LogTypes = append(o.LogTypes, newDstElement)
		}
	}

	if source.GetCommonLogLabels() != nil {
		if o.CommonLogLabels == nil {
			o.CommonLogLabels = make(map[string]string, len(source.GetCommonLogLabels()))
		}
		for key, sourceValue := range source.GetCommonLogLabels() {
			o.CommonLogLabels[key] = sourceValue
		}
	}
	o.ViolatingLog = source.GetViolatingLog()
}

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

func (o *Alert_State) GotenObjectExt() {}

func (o *Alert_State) MakeFullFieldMask() *Alert_State_FieldMask {
	return FullAlert_State_FieldMask()
}

func (o *Alert_State) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullAlert_State_FieldMask()
}

func (o *Alert_State) MakeDiffFieldMask(other *Alert_State) *Alert_State_FieldMask {
	if o == nil && other == nil {
		return &Alert_State_FieldMask{}
	}
	if o == nil || other == nil {
		return FullAlert_State_FieldMask()
	}

	res := &Alert_State_FieldMask{}
	if o.GetIsFiring() != other.GetIsFiring() {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsFiring})
	}
	if !proto.Equal(o.GetStartTime(), other.GetStartTime()) {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorStartTime})
	}
	if !proto.Equal(o.GetEndTime(), other.GetEndTime()) {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorEndTime})
	}

	if len(o.GetNotificationStatuses()) == len(other.GetNotificationStatuses()) {
		for i, lValue := range o.GetNotificationStatuses() {
			rValue := other.GetNotificationStatuses()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNotificationStatuses})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNotificationStatuses})
	}
	if o.GetEscalationLevel() != other.GetEscalationLevel() {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorEscalationLevel})
	}
	if o.GetAiAgentHandlingState() != other.GetAiAgentHandlingState() {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiAgentHandlingState})
	}
	if !proto.Equal(o.GetAiAgentLastStateChangeTime(), other.GetAiAgentLastStateChangeTime()) {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiAgentLastStateChangeTime})
	}
	if o.GetAiAgentDiagnosisNotes() != other.GetAiAgentDiagnosisNotes() {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiAgentDiagnosisNotes})
	}
	if o.GetAiRemediationArg() != other.GetAiRemediationArg() {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiRemediationArg})
	}
	{
		subMask := o.GetAiRemediation().MakeDiffFieldMask(other.GetAiRemediation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiRemediation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &AlertState_FieldSubPath{selector: AlertState_FieldPathSelectorAiRemediation, subPath: subpath})
			}
		}
	}
	if o.GetOperatorHandlingState() != other.GetOperatorHandlingState() {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorOperatorHandlingState})
	}
	if !proto.Equal(o.GetOperatorLastStateChangeTime(), other.GetOperatorLastStateChangeTime()) {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorOperatorLastStateChangeTime})
	}
	if o.GetOperatorNotes() != other.GetOperatorNotes() {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorOperatorNotes})
	}
	if o.GetLifecycleCompleted() != other.GetLifecycleCompleted() {
		res.Paths = append(res.Paths, &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorLifecycleCompleted})
	}
	return res
}

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

func (o *Alert_State) Clone() *Alert_State {
	if o == nil {
		return nil
	}
	result := &Alert_State{}
	result.IsFiring = o.IsFiring
	result.StartTime = proto.Clone(o.StartTime).(*timestamppb.Timestamp)
	result.EndTime = proto.Clone(o.EndTime).(*timestamppb.Timestamp)
	result.NotificationStatuses = make([]*Alert_State_Notification, len(o.NotificationStatuses))
	for i, sourceValue := range o.NotificationStatuses {
		result.NotificationStatuses[i] = sourceValue.Clone()
	}
	result.EscalationLevel = o.EscalationLevel
	result.AiAgentHandlingState = o.AiAgentHandlingState
	result.AiAgentLastStateChangeTime = proto.Clone(o.AiAgentLastStateChangeTime).(*timestamppb.Timestamp)
	result.AiAgentDiagnosisNotes = o.AiAgentDiagnosisNotes
	result.AiRemediationArg = o.AiRemediationArg
	result.AiRemediation = o.AiRemediation.Clone()
	result.OperatorHandlingState = o.OperatorHandlingState
	result.OperatorLastStateChangeTime = proto.Clone(o.OperatorLastStateChangeTime).(*timestamppb.Timestamp)
	result.OperatorNotes = o.OperatorNotes
	result.LifecycleCompleted = o.LifecycleCompleted
	return result
}

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

func (o *Alert_State) Merge(source *Alert_State) {
	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.GetEndTime() != nil {
		if o.EndTime == nil {
			o.EndTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.EndTime, source.GetEndTime())
	}
	for _, sourceValue := range source.GetNotificationStatuses() {
		exists := false
		for _, currentValue := range o.NotificationStatuses {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Alert_State_Notification
			if sourceValue != nil {
				newDstElement = new(Alert_State_Notification)
				newDstElement.Merge(sourceValue)
			}
			o.NotificationStatuses = append(o.NotificationStatuses, newDstElement)
		}
	}

	o.EscalationLevel = source.GetEscalationLevel()
	o.AiAgentHandlingState = source.GetAiAgentHandlingState()
	if source.GetAiAgentLastStateChangeTime() != nil {
		if o.AiAgentLastStateChangeTime == nil {
			o.AiAgentLastStateChangeTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.AiAgentLastStateChangeTime, source.GetAiAgentLastStateChangeTime())
	}
	o.AiAgentDiagnosisNotes = source.GetAiAgentDiagnosisNotes()
	o.AiRemediationArg = source.GetAiRemediationArg()
	if source.GetAiRemediation() != nil {
		if o.AiRemediation == nil {
			o.AiRemediation = new(rcommon.PolicySpec_AIAgentHandling_Remediation)
		}
		o.AiRemediation.Merge(source.GetAiRemediation())
	}
	o.OperatorHandlingState = source.GetOperatorHandlingState()
	if source.GetOperatorLastStateChangeTime() != nil {
		if o.OperatorLastStateChangeTime == nil {
			o.OperatorLastStateChangeTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.OperatorLastStateChangeTime, source.GetOperatorLastStateChangeTime())
	}
	o.OperatorNotes = source.GetOperatorNotes()
	o.LifecycleCompleted = source.GetLifecycleCompleted()
}

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

func (o *Alert_Internal) GotenObjectExt() {}

func (o *Alert_Internal) MakeFullFieldMask() *Alert_Internal_FieldMask {
	return FullAlert_Internal_FieldMask()
}

func (o *Alert_Internal) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullAlert_Internal_FieldMask()
}

func (o *Alert_Internal) MakeDiffFieldMask(other *Alert_Internal) *Alert_Internal_FieldMask {
	if o == nil && other == nil {
		return &Alert_Internal_FieldMask{}
	}
	if o == nil || other == nil {
		return FullAlert_Internal_FieldMask()
	}

	res := &Alert_Internal_FieldMask{}
	if o.GetAlertingLocation() != other.GetAlertingLocation() {
		res.Paths = append(res.Paths, &AlertInternal_FieldTerminalPath{selector: AlertInternal_FieldPathSelectorAlertingLocation})
	}
	return res
}

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

func (o *Alert_Internal) Clone() *Alert_Internal {
	if o == nil {
		return nil
	}
	result := &Alert_Internal{}
	result.AlertingLocation = o.AlertingLocation
	return result
}

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

func (o *Alert_Internal) Merge(source *Alert_Internal) {
	o.AlertingLocation = source.GetAlertingLocation()
}

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

func (o *Alert_TsInfo_TimeSeries) GotenObjectExt() {}

func (o *Alert_TsInfo_TimeSeries) MakeFullFieldMask() *Alert_TsInfo_TimeSeries_FieldMask {
	return FullAlert_TsInfo_TimeSeries_FieldMask()
}

func (o *Alert_TsInfo_TimeSeries) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullAlert_TsInfo_TimeSeries_FieldMask()
}

func (o *Alert_TsInfo_TimeSeries) MakeDiffFieldMask(other *Alert_TsInfo_TimeSeries) *Alert_TsInfo_TimeSeries_FieldMask {
	if o == nil && other == nil {
		return &Alert_TsInfo_TimeSeries_FieldMask{}
	}
	if o == nil || other == nil {
		return FullAlert_TsInfo_TimeSeries_FieldMask()
	}

	res := &Alert_TsInfo_TimeSeries_FieldMask{}
	if o.GetQueryName() != other.GetQueryName() {
		res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorQueryName})
	}

	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, &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorValues})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorValues})
	}

	if len(o.GetAnomalies()) == len(other.GetAnomalies()) {
		for i, lValue := range o.GetAnomalies() {
			rValue := other.GetAnomalies()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAnomalies})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAnomalies})
	}
	{
		subMask := o.GetUpperThreshold().MakeDiffFieldMask(other.GetUpperThreshold())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldSubPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetLowerThreshold().MakeDiffFieldMask(other.GetLowerThreshold())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldSubPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold, subPath: subpath})
			}
		}
	}
	if o.GetAnomalyThreshold() != other.GetAnomalyThreshold() {
		res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold})
	}
	if !proto.Equal(o.GetAfterDuration(), other.GetAfterDuration()) {
		res.Paths = append(res.Paths, &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration})
	}
	return res
}

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

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

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

func (o *Alert_TsInfo_TimeSeries) Merge(source *Alert_TsInfo_TimeSeries) {
	o.QueryName = source.GetQueryName()
	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)
		}
	}

	for _, sourceValue := range source.GetAnomalies() {
		exists := false
		for _, currentValue := range o.Anomalies {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement float64
			newDstElement = sourceValue
			o.Anomalies = append(o.Anomalies, 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())
	}
	o.AnomalyThreshold = source.GetAnomalyThreshold()
	if source.GetAfterDuration() != nil {
		if o.AfterDuration == nil {
			o.AfterDuration = new(durationpb.Duration)
		}
		proto.Merge(o.AfterDuration, source.GetAfterDuration())
	}
}

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

func (o *Alert_State_Notification) GotenObjectExt() {}

func (o *Alert_State_Notification) MakeFullFieldMask() *Alert_State_Notification_FieldMask {
	return FullAlert_State_Notification_FieldMask()
}

func (o *Alert_State_Notification) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullAlert_State_Notification_FieldMask()
}

func (o *Alert_State_Notification) MakeDiffFieldMask(other *Alert_State_Notification) *Alert_State_Notification_FieldMask {
	if o == nil && other == nil {
		return &Alert_State_Notification_FieldMask{}
	}
	if o == nil || other == nil {
		return FullAlert_State_Notification_FieldMask()
	}

	res := &Alert_State_Notification_FieldMask{}
	if o.GetKind() != other.GetKind() {
		res.Paths = append(res.Paths, &AlertStateNotification_FieldTerminalPath{selector: AlertStateNotification_FieldPathSelectorKind})
	}

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

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

func (o *Alert_State_Notification) Clone() *Alert_State_Notification {
	if o == nil {
		return nil
	}
	result := &Alert_State_Notification{}
	result.Kind = o.Kind
	result.PendingChannels = make([]*notification_channel.Reference, len(o.PendingChannels))
	for i, sourceValue := range o.PendingChannels {
		if sourceValue == nil {
			result.PendingChannels[i] = nil
		} else if data, err := sourceValue.ProtoString(); err != nil {
			panic(err)
		} else {
			result.PendingChannels[i] = &notification_channel.Reference{}
			if err := result.PendingChannels[i].ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	}
	return result
}

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

func (o *Alert_State_Notification) Merge(source *Alert_State_Notification) {
	o.Kind = source.GetKind()
	for _, sourceValue := range source.GetPendingChannels() {
		exists := false
		for _, currentValue := range o.PendingChannels {
			leftProtoStr, _ := currentValue.ProtoString()
			rightProtoStr, _ := sourceValue.ProtoString()
			if leftProtoStr == rightProtoStr {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *notification_channel.Reference
			if sourceValue != nil {
				if data, err := sourceValue.ProtoString(); err != nil {
					panic(err)
				} else {
					newDstElement = &notification_channel.Reference{}
					if err := newDstElement.ParseProtoString(data); err != nil {
						panic(err)
					}
				}
			}
			o.PendingChannels = append(o.PendingChannels, newDstElement)
		}
	}

}

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