alerting_policy_service.pb.object_ext.go

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

package alerting_policy_client

import (
	"fmt"
	"sort"

	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/fieldmaskpb"

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

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

// ensure the imports are used
var (
	_ = fmt.Stringer(nil)
	_ = sort.Interface(nil)

	_ = proto.Message(nil)
	_ = fieldmaskpb.FieldMask{}

	_ = gotenobject.FieldPath(nil)
)

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

func (o *GetAlertingPolicyRequest) GotenObjectExt() {}

func (o *GetAlertingPolicyRequest) MakeFullFieldMask() *GetAlertingPolicyRequest_FieldMask {
	return FullGetAlertingPolicyRequest_FieldMask()
}

func (o *GetAlertingPolicyRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullGetAlertingPolicyRequest_FieldMask()
}

func (o *GetAlertingPolicyRequest) MakeDiffFieldMask(other *GetAlertingPolicyRequest) *GetAlertingPolicyRequest_FieldMask {
	if o == nil && other == nil {
		return &GetAlertingPolicyRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullGetAlertingPolicyRequest_FieldMask()
	}

	res := &GetAlertingPolicyRequest_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &GetAlertingPolicyRequest_FieldTerminalPath{selector: GetAlertingPolicyRequest_FieldPathSelectorName})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &GetAlertingPolicyRequest_FieldTerminalPath{selector: GetAlertingPolicyRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &GetAlertingPolicyRequest_FieldTerminalPath{selector: GetAlertingPolicyRequest_FieldPathSelectorView})
	}
	return res
}

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

func (o *GetAlertingPolicyRequest) Clone() *GetAlertingPolicyRequest {
	if o == nil {
		return nil
	}
	result := &GetAlertingPolicyRequest{}
	if o.Name == nil {
		result.Name = nil
	} else if data, err := o.Name.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Name = &alerting_policy.Reference{}
		if err := result.Name.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*alerting_policy.AlertingPolicy_FieldMask)
	result.View = o.View
	return result
}

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

func (o *GetAlertingPolicyRequest) Merge(source *GetAlertingPolicyRequest) {
	if source.GetName() != nil {
		if data, err := source.GetName().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Name = &alerting_policy.Reference{}
			if err := o.Name.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Name = nil
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(alerting_policy.AlertingPolicy_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
}

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

func (o *BatchGetAlertingPoliciesRequest) GotenObjectExt() {}

func (o *BatchGetAlertingPoliciesRequest) MakeFullFieldMask() *BatchGetAlertingPoliciesRequest_FieldMask {
	return FullBatchGetAlertingPoliciesRequest_FieldMask()
}

func (o *BatchGetAlertingPoliciesRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullBatchGetAlertingPoliciesRequest_FieldMask()
}

func (o *BatchGetAlertingPoliciesRequest) MakeDiffFieldMask(other *BatchGetAlertingPoliciesRequest) *BatchGetAlertingPoliciesRequest_FieldMask {
	if o == nil && other == nil {
		return &BatchGetAlertingPoliciesRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullBatchGetAlertingPoliciesRequest_FieldMask()
	}

	res := &BatchGetAlertingPoliciesRequest_FieldMask{}

	if len(o.GetNames()) == len(other.GetNames()) {
		for i, lValue := range o.GetNames() {
			rValue := other.GetNames()[i]
			if lValue.String() != rValue.String() {
				res.Paths = append(res.Paths, &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorNames})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorNames})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorView})
	}
	return res
}

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

func (o *BatchGetAlertingPoliciesRequest) Clone() *BatchGetAlertingPoliciesRequest {
	if o == nil {
		return nil
	}
	result := &BatchGetAlertingPoliciesRequest{}
	result.Names = make([]*alerting_policy.Reference, len(o.Names))
	for i, sourceValue := range o.Names {
		if sourceValue == nil {
			result.Names[i] = nil
		} else if data, err := sourceValue.ProtoString(); err != nil {
			panic(err)
		} else {
			result.Names[i] = &alerting_policy.Reference{}
			if err := result.Names[i].ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*alerting_policy.AlertingPolicy_FieldMask)
	result.View = o.View
	return result
}

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

func (o *BatchGetAlertingPoliciesRequest) Merge(source *BatchGetAlertingPoliciesRequest) {
	for _, sourceValue := range source.GetNames() {
		exists := false
		for _, currentValue := range o.Names {
			leftProtoStr, _ := currentValue.ProtoString()
			rightProtoStr, _ := sourceValue.ProtoString()
			if leftProtoStr == rightProtoStr {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *alerting_policy.Reference
			if sourceValue != nil {
				if data, err := sourceValue.ProtoString(); err != nil {
					panic(err)
				} else {
					newDstElement = &alerting_policy.Reference{}
					if err := newDstElement.ParseProtoString(data); err != nil {
						panic(err)
					}
				}
			}
			o.Names = append(o.Names, newDstElement)
		}
	}

	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(alerting_policy.AlertingPolicy_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
}

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

func (o *BatchGetAlertingPoliciesResponse) GotenObjectExt() {}

func (o *BatchGetAlertingPoliciesResponse) MakeFullFieldMask() *BatchGetAlertingPoliciesResponse_FieldMask {
	return FullBatchGetAlertingPoliciesResponse_FieldMask()
}

func (o *BatchGetAlertingPoliciesResponse) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullBatchGetAlertingPoliciesResponse_FieldMask()
}

func (o *BatchGetAlertingPoliciesResponse) MakeDiffFieldMask(other *BatchGetAlertingPoliciesResponse) *BatchGetAlertingPoliciesResponse_FieldMask {
	if o == nil && other == nil {
		return &BatchGetAlertingPoliciesResponse_FieldMask{}
	}
	if o == nil || other == nil {
		return FullBatchGetAlertingPoliciesResponse_FieldMask()
	}

	res := &BatchGetAlertingPoliciesResponse_FieldMask{}

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

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

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

func (o *BatchGetAlertingPoliciesResponse) Clone() *BatchGetAlertingPoliciesResponse {
	if o == nil {
		return nil
	}
	result := &BatchGetAlertingPoliciesResponse{}
	result.AlertingPolicies = make([]*alerting_policy.AlertingPolicy, len(o.AlertingPolicies))
	for i, sourceValue := range o.AlertingPolicies {
		result.AlertingPolicies[i] = sourceValue.Clone()
	}
	result.Missing = make([]*alerting_policy.Reference, len(o.Missing))
	for i, sourceValue := range o.Missing {
		if sourceValue == nil {
			result.Missing[i] = nil
		} else if data, err := sourceValue.ProtoString(); err != nil {
			panic(err)
		} else {
			result.Missing[i] = &alerting_policy.Reference{}
			if err := result.Missing[i].ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	}
	return result
}

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

func (o *BatchGetAlertingPoliciesResponse) Merge(source *BatchGetAlertingPoliciesResponse) {
	for _, sourceValue := range source.GetAlertingPolicies() {
		exists := false
		for _, currentValue := range o.AlertingPolicies {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *alerting_policy.AlertingPolicy
			if sourceValue != nil {
				newDstElement = new(alerting_policy.AlertingPolicy)
				newDstElement.Merge(sourceValue)
			}
			o.AlertingPolicies = append(o.AlertingPolicies, newDstElement)
		}
	}

	for _, sourceValue := range source.GetMissing() {
		exists := false
		for _, currentValue := range o.Missing {
			leftProtoStr, _ := currentValue.ProtoString()
			rightProtoStr, _ := sourceValue.ProtoString()
			if leftProtoStr == rightProtoStr {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *alerting_policy.Reference
			if sourceValue != nil {
				if data, err := sourceValue.ProtoString(); err != nil {
					panic(err)
				} else {
					newDstElement = &alerting_policy.Reference{}
					if err := newDstElement.ParseProtoString(data); err != nil {
						panic(err)
					}
				}
			}
			o.Missing = append(o.Missing, newDstElement)
		}
	}

}

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

func (o *ListAlertingPoliciesRequest) GotenObjectExt() {}

func (o *ListAlertingPoliciesRequest) MakeFullFieldMask() *ListAlertingPoliciesRequest_FieldMask {
	return FullListAlertingPoliciesRequest_FieldMask()
}

func (o *ListAlertingPoliciesRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullListAlertingPoliciesRequest_FieldMask()
}

func (o *ListAlertingPoliciesRequest) MakeDiffFieldMask(other *ListAlertingPoliciesRequest) *ListAlertingPoliciesRequest_FieldMask {
	if o == nil && other == nil {
		return &ListAlertingPoliciesRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullListAlertingPoliciesRequest_FieldMask()
	}

	res := &ListAlertingPoliciesRequest_FieldMask{}
	if o.GetParent().String() != other.GetParent().String() {
		res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorParent})
	}
	if o.GetPageSize() != other.GetPageSize() {
		res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorPageSize})
	}
	if o.GetPageToken().String() != other.GetPageToken().String() {
		res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorPageToken})
	}
	if o.GetOrderBy().String() != other.GetOrderBy().String() {
		res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorOrderBy})
	}
	if o.GetFilter().String() != other.GetFilter().String() {
		res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorFilter})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorView})
	}
	return res
}

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

func (o *ListAlertingPoliciesRequest) Clone() *ListAlertingPoliciesRequest {
	if o == nil {
		return nil
	}
	result := &ListAlertingPoliciesRequest{}
	if o.Parent == nil {
		result.Parent = nil
	} else if data, err := o.Parent.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Parent = &alerting_policy.ParentName{}
		if err := result.Parent.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.PageSize = o.PageSize
	if o.PageToken == nil {
		result.PageToken = nil
	} else if data, err := o.PageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.PageToken = &alerting_policy.PagerCursor{}
		if err := result.PageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.OrderBy == nil {
		result.OrderBy = nil
	} else if data, err := o.OrderBy.ProtoString(); err != nil {
		panic(err)
	} else {
		result.OrderBy = &alerting_policy.OrderBy{}
		if err := result.OrderBy.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.Filter == nil {
		result.Filter = nil
	} else if data, err := o.Filter.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Filter = &alerting_policy.Filter{}
		if err := result.Filter.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*alerting_policy.AlertingPolicy_FieldMask)
	result.View = o.View
	return result
}

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

func (o *ListAlertingPoliciesRequest) Merge(source *ListAlertingPoliciesRequest) {
	if source.GetParent() != nil {
		if data, err := source.GetParent().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Parent = &alerting_policy.ParentName{}
			if err := o.Parent.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Parent = nil
	}
	o.PageSize = source.GetPageSize()
	if source.GetPageToken() != nil {
		if data, err := source.GetPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.PageToken = &alerting_policy.PagerCursor{}
			if err := o.PageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.PageToken = nil
	}
	if source.GetOrderBy() != nil {
		if data, err := source.GetOrderBy().ProtoString(); err != nil {
			panic(err)
		} else {
			o.OrderBy = &alerting_policy.OrderBy{}
			if err := o.OrderBy.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.OrderBy = nil
	}
	if source.GetFilter() != nil {
		if data, err := source.GetFilter().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Filter = &alerting_policy.Filter{}
			if err := o.Filter.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Filter = nil
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(alerting_policy.AlertingPolicy_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
}

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

func (o *ListAlertingPoliciesResponse) GotenObjectExt() {}

func (o *ListAlertingPoliciesResponse) MakeFullFieldMask() *ListAlertingPoliciesResponse_FieldMask {
	return FullListAlertingPoliciesResponse_FieldMask()
}

func (o *ListAlertingPoliciesResponse) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullListAlertingPoliciesResponse_FieldMask()
}

func (o *ListAlertingPoliciesResponse) MakeDiffFieldMask(other *ListAlertingPoliciesResponse) *ListAlertingPoliciesResponse_FieldMask {
	if o == nil && other == nil {
		return &ListAlertingPoliciesResponse_FieldMask{}
	}
	if o == nil || other == nil {
		return FullListAlertingPoliciesResponse_FieldMask()
	}

	res := &ListAlertingPoliciesResponse_FieldMask{}

	if len(o.GetAlertingPolicies()) == len(other.GetAlertingPolicies()) {
		for i, lValue := range o.GetAlertingPolicies() {
			rValue := other.GetAlertingPolicies()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies})
	}
	if o.GetPrevPageToken().String() != other.GetPrevPageToken().String() {
		res.Paths = append(res.Paths, &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken})
	}
	if o.GetNextPageToken().String() != other.GetNextPageToken().String() {
		res.Paths = append(res.Paths, &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken})
	}
	return res
}

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

func (o *ListAlertingPoliciesResponse) Clone() *ListAlertingPoliciesResponse {
	if o == nil {
		return nil
	}
	result := &ListAlertingPoliciesResponse{}
	result.AlertingPolicies = make([]*alerting_policy.AlertingPolicy, len(o.AlertingPolicies))
	for i, sourceValue := range o.AlertingPolicies {
		result.AlertingPolicies[i] = sourceValue.Clone()
	}
	if o.PrevPageToken == nil {
		result.PrevPageToken = nil
	} else if data, err := o.PrevPageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.PrevPageToken = &alerting_policy.PagerCursor{}
		if err := result.PrevPageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.NextPageToken == nil {
		result.NextPageToken = nil
	} else if data, err := o.NextPageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.NextPageToken = &alerting_policy.PagerCursor{}
		if err := result.NextPageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	return result
}

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

func (o *ListAlertingPoliciesResponse) Merge(source *ListAlertingPoliciesResponse) {
	for _, sourceValue := range source.GetAlertingPolicies() {
		exists := false
		for _, currentValue := range o.AlertingPolicies {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *alerting_policy.AlertingPolicy
			if sourceValue != nil {
				newDstElement = new(alerting_policy.AlertingPolicy)
				newDstElement.Merge(sourceValue)
			}
			o.AlertingPolicies = append(o.AlertingPolicies, newDstElement)
		}
	}

	if source.GetPrevPageToken() != nil {
		if data, err := source.GetPrevPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.PrevPageToken = &alerting_policy.PagerCursor{}
			if err := o.PrevPageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.PrevPageToken = nil
	}
	if source.GetNextPageToken() != nil {
		if data, err := source.GetNextPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.NextPageToken = &alerting_policy.PagerCursor{}
			if err := o.NextPageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.NextPageToken = nil
	}
}

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

func (o *WatchAlertingPolicyRequest) GotenObjectExt() {}

func (o *WatchAlertingPolicyRequest) MakeFullFieldMask() *WatchAlertingPolicyRequest_FieldMask {
	return FullWatchAlertingPolicyRequest_FieldMask()
}

func (o *WatchAlertingPolicyRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchAlertingPolicyRequest_FieldMask()
}

func (o *WatchAlertingPolicyRequest) MakeDiffFieldMask(other *WatchAlertingPolicyRequest) *WatchAlertingPolicyRequest_FieldMask {
	if o == nil && other == nil {
		return &WatchAlertingPolicyRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchAlertingPolicyRequest_FieldMask()
	}

	res := &WatchAlertingPolicyRequest_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &WatchAlertingPolicyRequest_FieldTerminalPath{selector: WatchAlertingPolicyRequest_FieldPathSelectorName})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &WatchAlertingPolicyRequest_FieldTerminalPath{selector: WatchAlertingPolicyRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &WatchAlertingPolicyRequest_FieldTerminalPath{selector: WatchAlertingPolicyRequest_FieldPathSelectorView})
	}
	return res
}

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

func (o *WatchAlertingPolicyRequest) Clone() *WatchAlertingPolicyRequest {
	if o == nil {
		return nil
	}
	result := &WatchAlertingPolicyRequest{}
	if o.Name == nil {
		result.Name = nil
	} else if data, err := o.Name.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Name = &alerting_policy.Reference{}
		if err := result.Name.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*alerting_policy.AlertingPolicy_FieldMask)
	result.View = o.View
	return result
}

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

func (o *WatchAlertingPolicyRequest) Merge(source *WatchAlertingPolicyRequest) {
	if source.GetName() != nil {
		if data, err := source.GetName().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Name = &alerting_policy.Reference{}
			if err := o.Name.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Name = nil
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(alerting_policy.AlertingPolicy_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
}

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

func (o *WatchAlertingPolicyResponse) GotenObjectExt() {}

func (o *WatchAlertingPolicyResponse) MakeFullFieldMask() *WatchAlertingPolicyResponse_FieldMask {
	return FullWatchAlertingPolicyResponse_FieldMask()
}

func (o *WatchAlertingPolicyResponse) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchAlertingPolicyResponse_FieldMask()
}

func (o *WatchAlertingPolicyResponse) MakeDiffFieldMask(other *WatchAlertingPolicyResponse) *WatchAlertingPolicyResponse_FieldMask {
	if o == nil && other == nil {
		return &WatchAlertingPolicyResponse_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchAlertingPolicyResponse_FieldMask()
	}

	res := &WatchAlertingPolicyResponse_FieldMask{}
	if !proto.Equal(o.GetChange(), other.GetChange()) {
		res.Paths = append(res.Paths, &WatchAlertingPolicyResponse_FieldTerminalPath{selector: WatchAlertingPolicyResponse_FieldPathSelectorChange})
	}
	return res
}

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

func (o *WatchAlertingPolicyResponse) Clone() *WatchAlertingPolicyResponse {
	if o == nil {
		return nil
	}
	result := &WatchAlertingPolicyResponse{}
	result.Change = proto.Clone(o.Change).(*alerting_policy.AlertingPolicyChange)
	return result
}

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

func (o *WatchAlertingPolicyResponse) Merge(source *WatchAlertingPolicyResponse) {
	if source.GetChange() != nil {
		if o.Change == nil {
			o.Change = new(alerting_policy.AlertingPolicyChange)
		}
		proto.Merge(o.Change, source.GetChange())
	}
}

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

func (o *WatchAlertingPoliciesRequest) GotenObjectExt() {}

func (o *WatchAlertingPoliciesRequest) MakeFullFieldMask() *WatchAlertingPoliciesRequest_FieldMask {
	return FullWatchAlertingPoliciesRequest_FieldMask()
}

func (o *WatchAlertingPoliciesRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchAlertingPoliciesRequest_FieldMask()
}

func (o *WatchAlertingPoliciesRequest) MakeDiffFieldMask(other *WatchAlertingPoliciesRequest) *WatchAlertingPoliciesRequest_FieldMask {
	if o == nil && other == nil {
		return &WatchAlertingPoliciesRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchAlertingPoliciesRequest_FieldMask()
	}

	res := &WatchAlertingPoliciesRequest_FieldMask{}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorType})
	}
	if o.GetParent().String() != other.GetParent().String() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorParent})
	}
	if o.GetPageSize() != other.GetPageSize() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorPageSize})
	}
	if o.GetPageToken().String() != other.GetPageToken().String() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorPageToken})
	}
	if o.GetOrderBy().String() != other.GetOrderBy().String() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy})
	}
	if o.GetResumeToken() != other.GetResumeToken() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken})
	}
	if o.GetFilter().String() != other.GetFilter().String() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorFilter})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask})
	}
	if o.GetView() != other.GetView() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorView})
	}
	if o.GetMaxChunkSize() != other.GetMaxChunkSize() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize})
	}
	return res
}

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

func (o *WatchAlertingPoliciesRequest) Clone() *WatchAlertingPoliciesRequest {
	if o == nil {
		return nil
	}
	result := &WatchAlertingPoliciesRequest{}
	result.Type = o.Type
	if o.Parent == nil {
		result.Parent = nil
	} else if data, err := o.Parent.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Parent = &alerting_policy.ParentReference{}
		if err := result.Parent.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.PageSize = o.PageSize
	if o.PageToken == nil {
		result.PageToken = nil
	} else if data, err := o.PageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.PageToken = &alerting_policy.PagerCursor{}
		if err := result.PageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.OrderBy == nil {
		result.OrderBy = nil
	} else if data, err := o.OrderBy.ProtoString(); err != nil {
		panic(err)
	} else {
		result.OrderBy = &alerting_policy.OrderBy{}
		if err := result.OrderBy.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.ResumeToken = o.ResumeToken
	if o.Filter == nil {
		result.Filter = nil
	} else if data, err := o.Filter.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Filter = &alerting_policy.Filter{}
		if err := result.Filter.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.FieldMask = proto.Clone(o.FieldMask).(*alerting_policy.AlertingPolicy_FieldMask)
	result.View = o.View
	result.MaxChunkSize = o.MaxChunkSize
	return result
}

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

func (o *WatchAlertingPoliciesRequest) Merge(source *WatchAlertingPoliciesRequest) {
	o.Type = source.GetType()
	if source.GetParent() != nil {
		if data, err := source.GetParent().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Parent = &alerting_policy.ParentReference{}
			if err := o.Parent.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Parent = nil
	}
	o.PageSize = source.GetPageSize()
	if source.GetPageToken() != nil {
		if data, err := source.GetPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.PageToken = &alerting_policy.PagerCursor{}
			if err := o.PageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.PageToken = nil
	}
	if source.GetOrderBy() != nil {
		if data, err := source.GetOrderBy().ProtoString(); err != nil {
			panic(err)
		} else {
			o.OrderBy = &alerting_policy.OrderBy{}
			if err := o.OrderBy.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.OrderBy = nil
	}
	o.ResumeToken = source.GetResumeToken()
	if source.GetFilter() != nil {
		if data, err := source.GetFilter().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Filter = &alerting_policy.Filter{}
			if err := o.Filter.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Filter = nil
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(alerting_policy.AlertingPolicy_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	o.View = source.GetView()
	o.MaxChunkSize = source.GetMaxChunkSize()
}

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

func (o *WatchAlertingPoliciesResponse) GotenObjectExt() {}

func (o *WatchAlertingPoliciesResponse) MakeFullFieldMask() *WatchAlertingPoliciesResponse_FieldMask {
	return FullWatchAlertingPoliciesResponse_FieldMask()
}

func (o *WatchAlertingPoliciesResponse) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchAlertingPoliciesResponse_FieldMask()
}

func (o *WatchAlertingPoliciesResponse) MakeDiffFieldMask(other *WatchAlertingPoliciesResponse) *WatchAlertingPoliciesResponse_FieldMask {
	if o == nil && other == nil {
		return &WatchAlertingPoliciesResponse_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchAlertingPoliciesResponse_FieldMask()
	}

	res := &WatchAlertingPoliciesResponse_FieldMask{}

	if len(o.GetAlertingPolicyChanges()) == len(other.GetAlertingPolicyChanges()) {
		for i, lValue := range o.GetAlertingPolicyChanges() {
			rValue := other.GetAlertingPolicyChanges()[i]
			if !proto.Equal(lValue, rValue) {
				res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges})
	}
	if o.GetIsCurrent() != other.GetIsCurrent() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent})
	}
	{
		subMask := o.GetPageTokenChange().MakeDiffFieldMask(other.GetPageTokenChange())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldSubPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange, subPath: subpath})
			}
		}
	}
	if o.GetResumeToken() != other.GetResumeToken() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken})
	}
	if o.GetSnapshotSize() != other.GetSnapshotSize() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize})
	}
	if o.GetIsSoftReset() != other.GetIsSoftReset() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset})
	}
	if o.GetIsHardReset() != other.GetIsHardReset() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset})
	}
	return res
}

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

func (o *WatchAlertingPoliciesResponse) Clone() *WatchAlertingPoliciesResponse {
	if o == nil {
		return nil
	}
	result := &WatchAlertingPoliciesResponse{}
	result.AlertingPolicyChanges = make([]*alerting_policy.AlertingPolicyChange, len(o.AlertingPolicyChanges))
	for i, sourceValue := range o.AlertingPolicyChanges {
		result.AlertingPolicyChanges[i] = proto.Clone(sourceValue).(*alerting_policy.AlertingPolicyChange)
	}
	result.IsCurrent = o.IsCurrent
	result.PageTokenChange = o.PageTokenChange.Clone()
	result.ResumeToken = o.ResumeToken
	result.SnapshotSize = o.SnapshotSize
	result.IsSoftReset = o.IsSoftReset
	result.IsHardReset = o.IsHardReset
	return result
}

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

func (o *WatchAlertingPoliciesResponse) Merge(source *WatchAlertingPoliciesResponse) {
	for _, sourceValue := range source.GetAlertingPolicyChanges() {
		exists := false
		for _, currentValue := range o.AlertingPolicyChanges {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *alerting_policy.AlertingPolicyChange
			if sourceValue != nil {
				newDstElement = new(alerting_policy.AlertingPolicyChange)
				proto.Merge(newDstElement, sourceValue)
			}
			o.AlertingPolicyChanges = append(o.AlertingPolicyChanges, newDstElement)
		}
	}

	o.IsCurrent = source.GetIsCurrent()
	if source.GetPageTokenChange() != nil {
		if o.PageTokenChange == nil {
			o.PageTokenChange = new(WatchAlertingPoliciesResponse_PageTokenChange)
		}
		o.PageTokenChange.Merge(source.GetPageTokenChange())
	}
	o.ResumeToken = source.GetResumeToken()
	o.SnapshotSize = source.GetSnapshotSize()
	o.IsSoftReset = source.GetIsSoftReset()
	o.IsHardReset = source.GetIsHardReset()
}

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

func (o *WatchAlertingPoliciesResponse_PageTokenChange) GotenObjectExt() {}

func (o *WatchAlertingPoliciesResponse_PageTokenChange) MakeFullFieldMask() *WatchAlertingPoliciesResponse_PageTokenChange_FieldMask {
	return FullWatchAlertingPoliciesResponse_PageTokenChange_FieldMask()
}

func (o *WatchAlertingPoliciesResponse_PageTokenChange) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullWatchAlertingPoliciesResponse_PageTokenChange_FieldMask()
}

func (o *WatchAlertingPoliciesResponse_PageTokenChange) MakeDiffFieldMask(other *WatchAlertingPoliciesResponse_PageTokenChange) *WatchAlertingPoliciesResponse_PageTokenChange_FieldMask {
	if o == nil && other == nil {
		return &WatchAlertingPoliciesResponse_PageTokenChange_FieldMask{}
	}
	if o == nil || other == nil {
		return FullWatchAlertingPoliciesResponse_PageTokenChange_FieldMask()
	}

	res := &WatchAlertingPoliciesResponse_PageTokenChange_FieldMask{}
	if o.GetPrevPageToken().String() != other.GetPrevPageToken().String() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath{selector: WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken})
	}
	if o.GetNextPageToken().String() != other.GetNextPageToken().String() {
		res.Paths = append(res.Paths, &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath{selector: WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken})
	}
	return res
}

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

func (o *WatchAlertingPoliciesResponse_PageTokenChange) Clone() *WatchAlertingPoliciesResponse_PageTokenChange {
	if o == nil {
		return nil
	}
	result := &WatchAlertingPoliciesResponse_PageTokenChange{}
	if o.PrevPageToken == nil {
		result.PrevPageToken = nil
	} else if data, err := o.PrevPageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.PrevPageToken = &alerting_policy.PagerCursor{}
		if err := result.PrevPageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.NextPageToken == nil {
		result.NextPageToken = nil
	} else if data, err := o.NextPageToken.ProtoString(); err != nil {
		panic(err)
	} else {
		result.NextPageToken = &alerting_policy.PagerCursor{}
		if err := result.NextPageToken.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	return result
}

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

func (o *WatchAlertingPoliciesResponse_PageTokenChange) Merge(source *WatchAlertingPoliciesResponse_PageTokenChange) {
	if source.GetPrevPageToken() != nil {
		if data, err := source.GetPrevPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.PrevPageToken = &alerting_policy.PagerCursor{}
			if err := o.PrevPageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.PrevPageToken = nil
	}
	if source.GetNextPageToken() != nil {
		if data, err := source.GetNextPageToken().ProtoString(); err != nil {
			panic(err)
		} else {
			o.NextPageToken = &alerting_policy.PagerCursor{}
			if err := o.NextPageToken.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.NextPageToken = nil
	}
}

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

func (o *CreateAlertingPolicyRequest) GotenObjectExt() {}

func (o *CreateAlertingPolicyRequest) MakeFullFieldMask() *CreateAlertingPolicyRequest_FieldMask {
	return FullCreateAlertingPolicyRequest_FieldMask()
}

func (o *CreateAlertingPolicyRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullCreateAlertingPolicyRequest_FieldMask()
}

func (o *CreateAlertingPolicyRequest) MakeDiffFieldMask(other *CreateAlertingPolicyRequest) *CreateAlertingPolicyRequest_FieldMask {
	if o == nil && other == nil {
		return &CreateAlertingPolicyRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullCreateAlertingPolicyRequest_FieldMask()
	}

	res := &CreateAlertingPolicyRequest_FieldMask{}
	if o.GetParent().String() != other.GetParent().String() {
		res.Paths = append(res.Paths, &CreateAlertingPolicyRequest_FieldTerminalPath{selector: CreateAlertingPolicyRequest_FieldPathSelectorParent})
	}
	{
		subMask := o.GetAlertingPolicy().MakeDiffFieldMask(other.GetAlertingPolicy())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &CreateAlertingPolicyRequest_FieldTerminalPath{selector: CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &CreateAlertingPolicyRequest_FieldSubPath{selector: CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy, subPath: subpath})
			}
		}
	}
	return res
}

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

func (o *CreateAlertingPolicyRequest) Clone() *CreateAlertingPolicyRequest {
	if o == nil {
		return nil
	}
	result := &CreateAlertingPolicyRequest{}
	if o.Parent == nil {
		result.Parent = nil
	} else if data, err := o.Parent.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Parent = &alerting_policy.ParentReference{}
		if err := result.Parent.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.AlertingPolicy = o.AlertingPolicy.Clone()
	return result
}

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

func (o *CreateAlertingPolicyRequest) Merge(source *CreateAlertingPolicyRequest) {
	if source.GetParent() != nil {
		if data, err := source.GetParent().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Parent = &alerting_policy.ParentReference{}
			if err := o.Parent.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Parent = nil
	}
	if source.GetAlertingPolicy() != nil {
		if o.AlertingPolicy == nil {
			o.AlertingPolicy = new(alerting_policy.AlertingPolicy)
		}
		o.AlertingPolicy.Merge(source.GetAlertingPolicy())
	}
}

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

func (o *UpdateAlertingPolicyRequest) GotenObjectExt() {}

func (o *UpdateAlertingPolicyRequest) MakeFullFieldMask() *UpdateAlertingPolicyRequest_FieldMask {
	return FullUpdateAlertingPolicyRequest_FieldMask()
}

func (o *UpdateAlertingPolicyRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullUpdateAlertingPolicyRequest_FieldMask()
}

func (o *UpdateAlertingPolicyRequest) MakeDiffFieldMask(other *UpdateAlertingPolicyRequest) *UpdateAlertingPolicyRequest_FieldMask {
	if o == nil && other == nil {
		return &UpdateAlertingPolicyRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullUpdateAlertingPolicyRequest_FieldMask()
	}

	res := &UpdateAlertingPolicyRequest_FieldMask{}
	{
		subMask := o.GetAlertingPolicy().MakeDiffFieldMask(other.GetAlertingPolicy())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &UpdateAlertingPolicyRequest_FieldTerminalPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &UpdateAlertingPolicyRequest_FieldSubPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy, subPath: subpath})
			}
		}
	}
	if !proto.Equal(o.GetUpdateMask(), other.GetUpdateMask()) {
		res.Paths = append(res.Paths, &UpdateAlertingPolicyRequest_FieldTerminalPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask})
	}
	{
		subMask := o.GetCas().MakeDiffFieldMask(other.GetCas())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &UpdateAlertingPolicyRequest_FieldTerminalPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorCas})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &UpdateAlertingPolicyRequest_FieldSubPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorCas, subPath: subpath})
			}
		}
	}
	return res
}

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

func (o *UpdateAlertingPolicyRequest) Clone() *UpdateAlertingPolicyRequest {
	if o == nil {
		return nil
	}
	result := &UpdateAlertingPolicyRequest{}
	result.AlertingPolicy = o.AlertingPolicy.Clone()
	result.UpdateMask = proto.Clone(o.UpdateMask).(*alerting_policy.AlertingPolicy_FieldMask)
	result.Cas = o.Cas.Clone()
	return result
}

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

func (o *UpdateAlertingPolicyRequest) Merge(source *UpdateAlertingPolicyRequest) {
	if source.GetAlertingPolicy() != nil {
		if o.AlertingPolicy == nil {
			o.AlertingPolicy = new(alerting_policy.AlertingPolicy)
		}
		o.AlertingPolicy.Merge(source.GetAlertingPolicy())
	}
	if source.GetUpdateMask() != nil {
		if o.UpdateMask == nil {
			o.UpdateMask = new(alerting_policy.AlertingPolicy_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetUpdateMask().ToProtoFieldMask(), o.UpdateMask.ToProtoFieldMask())
		if err := o.UpdateMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
	if source.GetCas() != nil {
		if o.Cas == nil {
			o.Cas = new(UpdateAlertingPolicyRequest_CAS)
		}
		o.Cas.Merge(source.GetCas())
	}
}

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

func (o *UpdateAlertingPolicyRequest_CAS) GotenObjectExt() {}

func (o *UpdateAlertingPolicyRequest_CAS) MakeFullFieldMask() *UpdateAlertingPolicyRequest_CAS_FieldMask {
	return FullUpdateAlertingPolicyRequest_CAS_FieldMask()
}

func (o *UpdateAlertingPolicyRequest_CAS) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullUpdateAlertingPolicyRequest_CAS_FieldMask()
}

func (o *UpdateAlertingPolicyRequest_CAS) MakeDiffFieldMask(other *UpdateAlertingPolicyRequest_CAS) *UpdateAlertingPolicyRequest_CAS_FieldMask {
	if o == nil && other == nil {
		return &UpdateAlertingPolicyRequest_CAS_FieldMask{}
	}
	if o == nil || other == nil {
		return FullUpdateAlertingPolicyRequest_CAS_FieldMask()
	}

	res := &UpdateAlertingPolicyRequest_CAS_FieldMask{}
	{
		subMask := o.GetConditionalState().MakeDiffFieldMask(other.GetConditionalState())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &UpdateAlertingPolicyRequestCAS_FieldTerminalPath{selector: UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &UpdateAlertingPolicyRequestCAS_FieldSubPath{selector: UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState, subPath: subpath})
			}
		}
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &UpdateAlertingPolicyRequestCAS_FieldTerminalPath{selector: UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask})
	}
	return res
}

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

func (o *UpdateAlertingPolicyRequest_CAS) Clone() *UpdateAlertingPolicyRequest_CAS {
	if o == nil {
		return nil
	}
	result := &UpdateAlertingPolicyRequest_CAS{}
	result.ConditionalState = o.ConditionalState.Clone()
	result.FieldMask = proto.Clone(o.FieldMask).(*alerting_policy.AlertingPolicy_FieldMask)
	return result
}

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

func (o *UpdateAlertingPolicyRequest_CAS) Merge(source *UpdateAlertingPolicyRequest_CAS) {
	if source.GetConditionalState() != nil {
		if o.ConditionalState == nil {
			o.ConditionalState = new(alerting_policy.AlertingPolicy)
		}
		o.ConditionalState.Merge(source.GetConditionalState())
	}
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(alerting_policy.AlertingPolicy_FieldMask)
		}
		mergedMask := fieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
}

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

func (o *DeleteAlertingPolicyRequest) GotenObjectExt() {}

func (o *DeleteAlertingPolicyRequest) MakeFullFieldMask() *DeleteAlertingPolicyRequest_FieldMask {
	return FullDeleteAlertingPolicyRequest_FieldMask()
}

func (o *DeleteAlertingPolicyRequest) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDeleteAlertingPolicyRequest_FieldMask()
}

func (o *DeleteAlertingPolicyRequest) MakeDiffFieldMask(other *DeleteAlertingPolicyRequest) *DeleteAlertingPolicyRequest_FieldMask {
	if o == nil && other == nil {
		return &DeleteAlertingPolicyRequest_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDeleteAlertingPolicyRequest_FieldMask()
	}

	res := &DeleteAlertingPolicyRequest_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &DeleteAlertingPolicyRequest_FieldTerminalPath{selector: DeleteAlertingPolicyRequest_FieldPathSelectorName})
	}
	return res
}

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

func (o *DeleteAlertingPolicyRequest) Clone() *DeleteAlertingPolicyRequest {
	if o == nil {
		return nil
	}
	result := &DeleteAlertingPolicyRequest{}
	if o.Name == nil {
		result.Name = nil
	} else if data, err := o.Name.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Name = &alerting_policy.Reference{}
		if err := result.Name.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	return result
}

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

func (o *DeleteAlertingPolicyRequest) Merge(source *DeleteAlertingPolicyRequest) {
	if source.GetName() != nil {
		if data, err := source.GetName().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Name = &alerting_policy.Reference{}
			if err := o.Name.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Name = nil
	}
}

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