alerting_policy_service.pb.fieldmask.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 (
	"encoding/json"
	"strings"

	firestorepb "google.golang.org/genproto/googleapis/firestore/v1"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/proto"
	preflect "google.golang.org/protobuf/reflect/protoreflect"
	"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"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	field_mask "google.golang.org/genproto/protobuf/field_mask"
)

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

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

	_ = new(gotenobject.FieldMask)
)

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

type GetAlertingPolicyRequest_FieldMask struct {
	Paths []GetAlertingPolicyRequest_FieldPath
}

func FullGetAlertingPolicyRequest_FieldMask() *GetAlertingPolicyRequest_FieldMask {
	res := &GetAlertingPolicyRequest_FieldMask{}
	res.Paths = append(res.Paths, &GetAlertingPolicyRequest_FieldTerminalPath{selector: GetAlertingPolicyRequest_FieldPathSelectorName})
	res.Paths = append(res.Paths, &GetAlertingPolicyRequest_FieldTerminalPath{selector: GetAlertingPolicyRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &GetAlertingPolicyRequest_FieldTerminalPath{selector: GetAlertingPolicyRequest_FieldPathSelectorView})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *GetAlertingPolicyRequest_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *GetAlertingPolicyRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseGetAlertingPolicyRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *GetAlertingPolicyRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *GetAlertingPolicyRequest_FieldMask) AppendPath(path GetAlertingPolicyRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *GetAlertingPolicyRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*GetAlertingPolicyRequest), source.(*GetAlertingPolicyRequest))
}

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *GetAlertingPolicyRequest_FieldTerminalPath:
			switch tp.selector {
			case GetAlertingPolicyRequest_FieldPathSelectorName:
				result.Name = source.Name
			case GetAlertingPolicyRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case GetAlertingPolicyRequest_FieldPathSelectorView:
				result.View = source.View
			}
		}
	}
	return result
}

func (fieldMask *GetAlertingPolicyRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*GetAlertingPolicyRequest))
}

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

type BatchGetAlertingPoliciesRequest_FieldMask struct {
	Paths []BatchGetAlertingPoliciesRequest_FieldPath
}

func FullBatchGetAlertingPoliciesRequest_FieldMask() *BatchGetAlertingPoliciesRequest_FieldMask {
	res := &BatchGetAlertingPoliciesRequest_FieldMask{}
	res.Paths = append(res.Paths, &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorNames})
	res.Paths = append(res.Paths, &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &BatchGetAlertingPoliciesRequest_FieldTerminalPath{selector: BatchGetAlertingPoliciesRequest_FieldPathSelectorView})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *BatchGetAlertingPoliciesRequest_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *BatchGetAlertingPoliciesRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseBatchGetAlertingPoliciesRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *BatchGetAlertingPoliciesRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *BatchGetAlertingPoliciesRequest_FieldMask) AppendPath(path BatchGetAlertingPoliciesRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *BatchGetAlertingPoliciesRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*BatchGetAlertingPoliciesRequest), source.(*BatchGetAlertingPoliciesRequest))
}

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *BatchGetAlertingPoliciesRequest_FieldTerminalPath:
			switch tp.selector {
			case BatchGetAlertingPoliciesRequest_FieldPathSelectorNames:
				result.Names = source.Names
			case BatchGetAlertingPoliciesRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case BatchGetAlertingPoliciesRequest_FieldPathSelectorView:
				result.View = source.View
			}
		}
	}
	return result
}

func (fieldMask *BatchGetAlertingPoliciesRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*BatchGetAlertingPoliciesRequest))
}

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

type BatchGetAlertingPoliciesResponse_FieldMask struct {
	Paths []BatchGetAlertingPoliciesResponse_FieldPath
}

func FullBatchGetAlertingPoliciesResponse_FieldMask() *BatchGetAlertingPoliciesResponse_FieldMask {
	res := &BatchGetAlertingPoliciesResponse_FieldMask{}
	res.Paths = append(res.Paths, &BatchGetAlertingPoliciesResponse_FieldTerminalPath{selector: BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies})
	res.Paths = append(res.Paths, &BatchGetAlertingPoliciesResponse_FieldTerminalPath{selector: BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *BatchGetAlertingPoliciesResponse_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *BatchGetAlertingPoliciesResponse_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseBatchGetAlertingPoliciesResponse_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *BatchGetAlertingPoliciesResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *BatchGetAlertingPoliciesResponse_FieldMask) Subtract(other *BatchGetAlertingPoliciesResponse_FieldMask) *BatchGetAlertingPoliciesResponse_FieldMask {
	result := &BatchGetAlertingPoliciesResponse_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[BatchGetAlertingPoliciesResponse_FieldPathSelector]gotenobject.FieldMask{
		BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies: &alerting_policy.AlertingPolicy_FieldMask{},
	}
	mySubMasks := map[BatchGetAlertingPoliciesResponse_FieldPathSelector]gotenobject.FieldMask{
		BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies: &alerting_policy.AlertingPolicy_FieldMask{},
	}

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

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *BatchGetAlertingPoliciesResponse_FieldMask) FilterInputFields() *BatchGetAlertingPoliciesResponse_FieldMask {
	result := &BatchGetAlertingPoliciesResponse_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
			if _, ok := path.(*BatchGetAlertingPoliciesResponse_FieldTerminalPath); ok {
				for _, subpath := range alerting_policy.FullAlertingPolicy_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &BatchGetAlertingPoliciesResponse_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*BatchGetAlertingPoliciesResponse_FieldSubPath); ok {
				selectedMask := &alerting_policy.AlertingPolicy_FieldMask{
					Paths: []alerting_policy.AlertingPolicy_FieldPath{sub.subPath.(alerting_policy.AlertingPolicy_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &BatchGetAlertingPoliciesResponse_FieldSubPath{selector: BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

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

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

func (fieldMask *BatchGetAlertingPoliciesResponse_FieldMask) AppendPath(path BatchGetAlertingPoliciesResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *BatchGetAlertingPoliciesResponse_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*BatchGetAlertingPoliciesResponse), source.(*BatchGetAlertingPoliciesResponse))
}

func (fieldMask *BatchGetAlertingPoliciesResponse_FieldMask) Project(source *BatchGetAlertingPoliciesResponse) *BatchGetAlertingPoliciesResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &BatchGetAlertingPoliciesResponse{}
	alertingPoliciesMask := &alerting_policy.AlertingPolicy_FieldMask{}
	wholeAlertingPoliciesAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *BatchGetAlertingPoliciesResponse_FieldTerminalPath:
			switch tp.selector {
			case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
				result.AlertingPolicies = source.AlertingPolicies
				wholeAlertingPoliciesAccepted = true
			case BatchGetAlertingPoliciesResponse_FieldPathSelectorMissing:
				result.Missing = source.Missing
			}
		case *BatchGetAlertingPoliciesResponse_FieldSubPath:
			switch tp.selector {
			case BatchGetAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
				alertingPoliciesMask.AppendPath(tp.subPath.(alerting_policy.AlertingPolicy_FieldPath))
			}
		}
	}
	if wholeAlertingPoliciesAccepted == false && len(alertingPoliciesMask.Paths) > 0 {
		for _, sourceItem := range source.GetAlertingPolicies() {
			result.AlertingPolicies = append(result.AlertingPolicies, alertingPoliciesMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *BatchGetAlertingPoliciesResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*BatchGetAlertingPoliciesResponse))
}

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

type ListAlertingPoliciesRequest_FieldMask struct {
	Paths []ListAlertingPoliciesRequest_FieldPath
}

func FullListAlertingPoliciesRequest_FieldMask() *ListAlertingPoliciesRequest_FieldMask {
	res := &ListAlertingPoliciesRequest_FieldMask{}
	res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorPageSize})
	res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorPageToken})
	res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorOrderBy})
	res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorFilter})
	res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorView})
	res.Paths = append(res.Paths, &ListAlertingPoliciesRequest_FieldTerminalPath{selector: ListAlertingPoliciesRequest_FieldPathSelectorIncludePagingInfo})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *ListAlertingPoliciesRequest_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *ListAlertingPoliciesRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseListAlertingPoliciesRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *ListAlertingPoliciesRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *ListAlertingPoliciesRequest_FieldMask) AppendPath(path ListAlertingPoliciesRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *ListAlertingPoliciesRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*ListAlertingPoliciesRequest), source.(*ListAlertingPoliciesRequest))
}

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *ListAlertingPoliciesRequest_FieldTerminalPath:
			switch tp.selector {
			case ListAlertingPoliciesRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case ListAlertingPoliciesRequest_FieldPathSelectorPageSize:
				result.PageSize = source.PageSize
			case ListAlertingPoliciesRequest_FieldPathSelectorPageToken:
				result.PageToken = source.PageToken
			case ListAlertingPoliciesRequest_FieldPathSelectorOrderBy:
				result.OrderBy = source.OrderBy
			case ListAlertingPoliciesRequest_FieldPathSelectorFilter:
				result.Filter = source.Filter
			case ListAlertingPoliciesRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case ListAlertingPoliciesRequest_FieldPathSelectorView:
				result.View = source.View
			case ListAlertingPoliciesRequest_FieldPathSelectorIncludePagingInfo:
				result.IncludePagingInfo = source.IncludePagingInfo
			}
		}
	}
	return result
}

func (fieldMask *ListAlertingPoliciesRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*ListAlertingPoliciesRequest))
}

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

type ListAlertingPoliciesResponse_FieldMask struct {
	Paths []ListAlertingPoliciesResponse_FieldPath
}

func FullListAlertingPoliciesResponse_FieldMask() *ListAlertingPoliciesResponse_FieldMask {
	res := &ListAlertingPoliciesResponse_FieldMask{}
	res.Paths = append(res.Paths, &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies})
	res.Paths = append(res.Paths, &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken})
	res.Paths = append(res.Paths, &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken})
	res.Paths = append(res.Paths, &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorCurrentOffset})
	res.Paths = append(res.Paths, &ListAlertingPoliciesResponse_FieldTerminalPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorTotalResultsCount})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *ListAlertingPoliciesResponse_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *ListAlertingPoliciesResponse_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseListAlertingPoliciesResponse_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *ListAlertingPoliciesResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *ListAlertingPoliciesResponse_FieldMask) Subtract(other *ListAlertingPoliciesResponse_FieldMask) *ListAlertingPoliciesResponse_FieldMask {
	result := &ListAlertingPoliciesResponse_FieldMask{}
	removedSelectors := make([]bool, 5)
	otherSubMasks := map[ListAlertingPoliciesResponse_FieldPathSelector]gotenobject.FieldMask{
		ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies: &alerting_policy.AlertingPolicy_FieldMask{},
	}
	mySubMasks := map[ListAlertingPoliciesResponse_FieldPathSelector]gotenobject.FieldMask{
		ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies: &alerting_policy.AlertingPolicy_FieldMask{},
	}

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

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *ListAlertingPoliciesResponse_FieldMask) FilterInputFields() *ListAlertingPoliciesResponse_FieldMask {
	result := &ListAlertingPoliciesResponse_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
			if _, ok := path.(*ListAlertingPoliciesResponse_FieldTerminalPath); ok {
				for _, subpath := range alerting_policy.FullAlertingPolicy_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &ListAlertingPoliciesResponse_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*ListAlertingPoliciesResponse_FieldSubPath); ok {
				selectedMask := &alerting_policy.AlertingPolicy_FieldMask{
					Paths: []alerting_policy.AlertingPolicy_FieldPath{sub.subPath.(alerting_policy.AlertingPolicy_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &ListAlertingPoliciesResponse_FieldSubPath{selector: ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

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

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

func (fieldMask *ListAlertingPoliciesResponse_FieldMask) AppendPath(path ListAlertingPoliciesResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *ListAlertingPoliciesResponse_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*ListAlertingPoliciesResponse), source.(*ListAlertingPoliciesResponse))
}

func (fieldMask *ListAlertingPoliciesResponse_FieldMask) Project(source *ListAlertingPoliciesResponse) *ListAlertingPoliciesResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &ListAlertingPoliciesResponse{}
	alertingPoliciesMask := &alerting_policy.AlertingPolicy_FieldMask{}
	wholeAlertingPoliciesAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *ListAlertingPoliciesResponse_FieldTerminalPath:
			switch tp.selector {
			case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
				result.AlertingPolicies = source.AlertingPolicies
				wholeAlertingPoliciesAccepted = true
			case ListAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
				result.PrevPageToken = source.PrevPageToken
			case ListAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
				result.NextPageToken = source.NextPageToken
			case ListAlertingPoliciesResponse_FieldPathSelectorCurrentOffset:
				result.CurrentOffset = source.CurrentOffset
			case ListAlertingPoliciesResponse_FieldPathSelectorTotalResultsCount:
				result.TotalResultsCount = source.TotalResultsCount
			}
		case *ListAlertingPoliciesResponse_FieldSubPath:
			switch tp.selector {
			case ListAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
				alertingPoliciesMask.AppendPath(tp.subPath.(alerting_policy.AlertingPolicy_FieldPath))
			}
		}
	}
	if wholeAlertingPoliciesAccepted == false && len(alertingPoliciesMask.Paths) > 0 {
		for _, sourceItem := range source.GetAlertingPolicies() {
			result.AlertingPolicies = append(result.AlertingPolicies, alertingPoliciesMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *ListAlertingPoliciesResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*ListAlertingPoliciesResponse))
}

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

type WatchAlertingPolicyRequest_FieldMask struct {
	Paths []WatchAlertingPolicyRequest_FieldPath
}

func FullWatchAlertingPolicyRequest_FieldMask() *WatchAlertingPolicyRequest_FieldMask {
	res := &WatchAlertingPolicyRequest_FieldMask{}
	res.Paths = append(res.Paths, &WatchAlertingPolicyRequest_FieldTerminalPath{selector: WatchAlertingPolicyRequest_FieldPathSelectorName})
	res.Paths = append(res.Paths, &WatchAlertingPolicyRequest_FieldTerminalPath{selector: WatchAlertingPolicyRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &WatchAlertingPolicyRequest_FieldTerminalPath{selector: WatchAlertingPolicyRequest_FieldPathSelectorView})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *WatchAlertingPolicyRequest_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *WatchAlertingPolicyRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseWatchAlertingPolicyRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *WatchAlertingPolicyRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchAlertingPolicyRequest_FieldMask) AppendPath(path WatchAlertingPolicyRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *WatchAlertingPolicyRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*WatchAlertingPolicyRequest), source.(*WatchAlertingPolicyRequest))
}

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchAlertingPolicyRequest_FieldTerminalPath:
			switch tp.selector {
			case WatchAlertingPolicyRequest_FieldPathSelectorName:
				result.Name = source.Name
			case WatchAlertingPolicyRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case WatchAlertingPolicyRequest_FieldPathSelectorView:
				result.View = source.View
			}
		}
	}
	return result
}

func (fieldMask *WatchAlertingPolicyRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchAlertingPolicyRequest))
}

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

type WatchAlertingPolicyResponse_FieldMask struct {
	Paths []WatchAlertingPolicyResponse_FieldPath
}

func FullWatchAlertingPolicyResponse_FieldMask() *WatchAlertingPolicyResponse_FieldMask {
	res := &WatchAlertingPolicyResponse_FieldMask{}
	res.Paths = append(res.Paths, &WatchAlertingPolicyResponse_FieldTerminalPath{selector: WatchAlertingPolicyResponse_FieldPathSelectorChange})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *WatchAlertingPolicyResponse_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *WatchAlertingPolicyResponse_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseWatchAlertingPolicyResponse_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *WatchAlertingPolicyResponse_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchAlertingPolicyResponse_FieldMask) AppendPath(path WatchAlertingPolicyResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *WatchAlertingPolicyResponse_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*WatchAlertingPolicyResponse), source.(*WatchAlertingPolicyResponse))
}

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

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

func (fieldMask *WatchAlertingPolicyResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchAlertingPolicyResponse))
}

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

type WatchAlertingPoliciesRequest_FieldMask struct {
	Paths []WatchAlertingPoliciesRequest_FieldPath
}

func FullWatchAlertingPoliciesRequest_FieldMask() *WatchAlertingPoliciesRequest_FieldMask {
	res := &WatchAlertingPoliciesRequest_FieldMask{}
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorType})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorPageSize})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorPageToken})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorFilter})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorView})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesRequest_FieldTerminalPath{selector: WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *WatchAlertingPoliciesRequest_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *WatchAlertingPoliciesRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseWatchAlertingPoliciesRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *WatchAlertingPoliciesRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchAlertingPoliciesRequest_FieldMask) AppendPath(path WatchAlertingPoliciesRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *WatchAlertingPoliciesRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*WatchAlertingPoliciesRequest), source.(*WatchAlertingPoliciesRequest))
}

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchAlertingPoliciesRequest_FieldTerminalPath:
			switch tp.selector {
			case WatchAlertingPoliciesRequest_FieldPathSelectorType:
				result.Type = source.Type
			case WatchAlertingPoliciesRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case WatchAlertingPoliciesRequest_FieldPathSelectorPageSize:
				result.PageSize = source.PageSize
			case WatchAlertingPoliciesRequest_FieldPathSelectorPageToken:
				result.PageToken = source.PageToken
			case WatchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
				result.OrderBy = source.OrderBy
			case WatchAlertingPoliciesRequest_FieldPathSelectorResumeToken:
				result.ResumeToken = source.ResumeToken
			case WatchAlertingPoliciesRequest_FieldPathSelectorStartingTime:
				result.StartingTime = source.StartingTime
			case WatchAlertingPoliciesRequest_FieldPathSelectorFilter:
				result.Filter = source.Filter
			case WatchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case WatchAlertingPoliciesRequest_FieldPathSelectorView:
				result.View = source.View
			case WatchAlertingPoliciesRequest_FieldPathSelectorMaxChunkSize:
				result.MaxChunkSize = source.MaxChunkSize
			}
		}
	}
	return result
}

func (fieldMask *WatchAlertingPoliciesRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchAlertingPoliciesRequest))
}

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

type WatchAlertingPoliciesResponse_FieldMask struct {
	Paths []WatchAlertingPoliciesResponse_FieldPath
}

func FullWatchAlertingPoliciesResponse_FieldMask() *WatchAlertingPoliciesResponse_FieldMask {
	res := &WatchAlertingPoliciesResponse_FieldMask{}
	res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesResponse_FieldTerminalPath{selector: WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *WatchAlertingPoliciesResponse_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *WatchAlertingPoliciesResponse_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseWatchAlertingPoliciesResponse_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *WatchAlertingPoliciesResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *WatchAlertingPoliciesResponse_FieldMask) Subtract(other *WatchAlertingPoliciesResponse_FieldMask) *WatchAlertingPoliciesResponse_FieldMask {
	result := &WatchAlertingPoliciesResponse_FieldMask{}
	removedSelectors := make([]bool, 7)
	otherSubMasks := map[WatchAlertingPoliciesResponse_FieldPathSelector]gotenobject.FieldMask{
		WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange: &WatchAlertingPoliciesResponse_PageTokenChange_FieldMask{},
	}
	mySubMasks := map[WatchAlertingPoliciesResponse_FieldPathSelector]gotenobject.FieldMask{
		WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange: &WatchAlertingPoliciesResponse_PageTokenChange_FieldMask{},
	}

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchAlertingPoliciesResponse_FieldMask) AppendPath(path WatchAlertingPoliciesResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *WatchAlertingPoliciesResponse_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*WatchAlertingPoliciesResponse), source.(*WatchAlertingPoliciesResponse))
}

func (fieldMask *WatchAlertingPoliciesResponse_FieldMask) Project(source *WatchAlertingPoliciesResponse) *WatchAlertingPoliciesResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &WatchAlertingPoliciesResponse{}
	pageTokenChangeMask := &WatchAlertingPoliciesResponse_PageTokenChange_FieldMask{}
	wholePageTokenChangeAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchAlertingPoliciesResponse_FieldTerminalPath:
			switch tp.selector {
			case WatchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicyChanges:
				result.AlertingPolicyChanges = source.AlertingPolicyChanges
			case WatchAlertingPoliciesResponse_FieldPathSelectorIsCurrent:
				result.IsCurrent = source.IsCurrent
			case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
				result.PageTokenChange = source.PageTokenChange
				wholePageTokenChangeAccepted = true
			case WatchAlertingPoliciesResponse_FieldPathSelectorResumeToken:
				result.ResumeToken = source.ResumeToken
			case WatchAlertingPoliciesResponse_FieldPathSelectorSnapshotSize:
				result.SnapshotSize = source.SnapshotSize
			case WatchAlertingPoliciesResponse_FieldPathSelectorIsSoftReset:
				result.IsSoftReset = source.IsSoftReset
			case WatchAlertingPoliciesResponse_FieldPathSelectorIsHardReset:
				result.IsHardReset = source.IsHardReset
			}
		case *WatchAlertingPoliciesResponse_FieldSubPath:
			switch tp.selector {
			case WatchAlertingPoliciesResponse_FieldPathSelectorPageTokenChange:
				pageTokenChangeMask.AppendPath(tp.subPath.(WatchAlertingPoliciesResponsePageTokenChange_FieldPath))
			}
		}
	}
	if wholePageTokenChangeAccepted == false && len(pageTokenChangeMask.Paths) > 0 {
		result.PageTokenChange = pageTokenChangeMask.Project(source.GetPageTokenChange())
	}
	return result
}

func (fieldMask *WatchAlertingPoliciesResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchAlertingPoliciesResponse))
}

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

type WatchAlertingPoliciesResponse_PageTokenChange_FieldMask struct {
	Paths []WatchAlertingPoliciesResponsePageTokenChange_FieldPath
}

func FullWatchAlertingPoliciesResponse_PageTokenChange_FieldMask() *WatchAlertingPoliciesResponse_PageTokenChange_FieldMask {
	res := &WatchAlertingPoliciesResponse_PageTokenChange_FieldMask{}
	res.Paths = append(res.Paths, &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath{selector: WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken})
	res.Paths = append(res.Paths, &WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath{selector: WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *WatchAlertingPoliciesResponse_PageTokenChange_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *WatchAlertingPoliciesResponse_PageTokenChange_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseWatchAlertingPoliciesResponsePageTokenChange_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *WatchAlertingPoliciesResponse_PageTokenChange_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchAlertingPoliciesResponse_PageTokenChange_FieldMask) AppendPath(path WatchAlertingPoliciesResponsePageTokenChange_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *WatchAlertingPoliciesResponse_PageTokenChange_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*WatchAlertingPoliciesResponse_PageTokenChange), source.(*WatchAlertingPoliciesResponse_PageTokenChange))
}

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchAlertingPoliciesResponsePageTokenChange_FieldTerminalPath:
			switch tp.selector {
			case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
				result.PrevPageToken = source.PrevPageToken
			case WatchAlertingPoliciesResponsePageTokenChange_FieldPathSelectorNextPageToken:
				result.NextPageToken = source.NextPageToken
			}
		}
	}
	return result
}

func (fieldMask *WatchAlertingPoliciesResponse_PageTokenChange_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchAlertingPoliciesResponse_PageTokenChange))
}

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

type CreateAlertingPolicyRequest_FieldMask struct {
	Paths []CreateAlertingPolicyRequest_FieldPath
}

func FullCreateAlertingPolicyRequest_FieldMask() *CreateAlertingPolicyRequest_FieldMask {
	res := &CreateAlertingPolicyRequest_FieldMask{}
	res.Paths = append(res.Paths, &CreateAlertingPolicyRequest_FieldTerminalPath{selector: CreateAlertingPolicyRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &CreateAlertingPolicyRequest_FieldTerminalPath{selector: CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *CreateAlertingPolicyRequest_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *CreateAlertingPolicyRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseCreateAlertingPolicyRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *CreateAlertingPolicyRequest_FieldMask) ProtoMessage() {}

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

func (fieldMask *CreateAlertingPolicyRequest_FieldMask) Subtract(other *CreateAlertingPolicyRequest_FieldMask) *CreateAlertingPolicyRequest_FieldMask {
	result := &CreateAlertingPolicyRequest_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[CreateAlertingPolicyRequest_FieldPathSelector]gotenobject.FieldMask{
		CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy: &alerting_policy.AlertingPolicy_FieldMask{},
	}
	mySubMasks := map[CreateAlertingPolicyRequest_FieldPathSelector]gotenobject.FieldMask{
		CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy: &alerting_policy.AlertingPolicy_FieldMask{},
	}

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

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *CreateAlertingPolicyRequest_FieldMask) FilterInputFields() *CreateAlertingPolicyRequest_FieldMask {
	result := &CreateAlertingPolicyRequest_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
			if _, ok := path.(*CreateAlertingPolicyRequest_FieldTerminalPath); ok {
				for _, subpath := range alerting_policy.FullAlertingPolicy_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &CreateAlertingPolicyRequest_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*CreateAlertingPolicyRequest_FieldSubPath); ok {
				selectedMask := &alerting_policy.AlertingPolicy_FieldMask{
					Paths: []alerting_policy.AlertingPolicy_FieldPath{sub.subPath.(alerting_policy.AlertingPolicy_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &CreateAlertingPolicyRequest_FieldSubPath{selector: CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

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

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

func (fieldMask *CreateAlertingPolicyRequest_FieldMask) AppendPath(path CreateAlertingPolicyRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *CreateAlertingPolicyRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*CreateAlertingPolicyRequest), source.(*CreateAlertingPolicyRequest))
}

func (fieldMask *CreateAlertingPolicyRequest_FieldMask) Project(source *CreateAlertingPolicyRequest) *CreateAlertingPolicyRequest {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &CreateAlertingPolicyRequest{}
	alertingPolicyMask := &alerting_policy.AlertingPolicy_FieldMask{}
	wholeAlertingPolicyAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *CreateAlertingPolicyRequest_FieldTerminalPath:
			switch tp.selector {
			case CreateAlertingPolicyRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
				result.AlertingPolicy = source.AlertingPolicy
				wholeAlertingPolicyAccepted = true
			}
		case *CreateAlertingPolicyRequest_FieldSubPath:
			switch tp.selector {
			case CreateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
				alertingPolicyMask.AppendPath(tp.subPath.(alerting_policy.AlertingPolicy_FieldPath))
			}
		}
	}
	if wholeAlertingPolicyAccepted == false && len(alertingPolicyMask.Paths) > 0 {
		result.AlertingPolicy = alertingPolicyMask.Project(source.GetAlertingPolicy())
	}
	return result
}

func (fieldMask *CreateAlertingPolicyRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*CreateAlertingPolicyRequest))
}

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

type UpdateAlertingPolicyRequest_FieldMask struct {
	Paths []UpdateAlertingPolicyRequest_FieldPath
}

func FullUpdateAlertingPolicyRequest_FieldMask() *UpdateAlertingPolicyRequest_FieldMask {
	res := &UpdateAlertingPolicyRequest_FieldMask{}
	res.Paths = append(res.Paths, &UpdateAlertingPolicyRequest_FieldTerminalPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy})
	res.Paths = append(res.Paths, &UpdateAlertingPolicyRequest_FieldTerminalPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask})
	res.Paths = append(res.Paths, &UpdateAlertingPolicyRequest_FieldTerminalPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorCas})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *UpdateAlertingPolicyRequest_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *UpdateAlertingPolicyRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseUpdateAlertingPolicyRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *UpdateAlertingPolicyRequest_FieldMask) ProtoMessage() {}

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

func (fieldMask *UpdateAlertingPolicyRequest_FieldMask) Subtract(other *UpdateAlertingPolicyRequest_FieldMask) *UpdateAlertingPolicyRequest_FieldMask {
	result := &UpdateAlertingPolicyRequest_FieldMask{}
	removedSelectors := make([]bool, 3)
	otherSubMasks := map[UpdateAlertingPolicyRequest_FieldPathSelector]gotenobject.FieldMask{
		UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy: &alerting_policy.AlertingPolicy_FieldMask{},
		UpdateAlertingPolicyRequest_FieldPathSelectorCas:            &UpdateAlertingPolicyRequest_CAS_FieldMask{},
	}
	mySubMasks := map[UpdateAlertingPolicyRequest_FieldPathSelector]gotenobject.FieldMask{
		UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy: &alerting_policy.AlertingPolicy_FieldMask{},
		UpdateAlertingPolicyRequest_FieldPathSelectorCas:            &UpdateAlertingPolicyRequest_CAS_FieldMask{},
	}

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

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *UpdateAlertingPolicyRequest_FieldMask) FilterInputFields() *UpdateAlertingPolicyRequest_FieldMask {
	result := &UpdateAlertingPolicyRequest_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
			if _, ok := path.(*UpdateAlertingPolicyRequest_FieldTerminalPath); ok {
				for _, subpath := range alerting_policy.FullAlertingPolicy_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateAlertingPolicyRequest_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*UpdateAlertingPolicyRequest_FieldSubPath); ok {
				selectedMask := &alerting_policy.AlertingPolicy_FieldMask{
					Paths: []alerting_policy.AlertingPolicy_FieldPath{sub.subPath.(alerting_policy.AlertingPolicy_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateAlertingPolicyRequest_FieldSubPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy, subPath: allowedPath})
				}
			}
		case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
			if _, ok := path.(*UpdateAlertingPolicyRequest_FieldTerminalPath); ok {
				for _, subpath := range FullUpdateAlertingPolicyRequest_CAS_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateAlertingPolicyRequest_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*UpdateAlertingPolicyRequest_FieldSubPath); ok {
				selectedMask := &UpdateAlertingPolicyRequest_CAS_FieldMask{
					Paths: []UpdateAlertingPolicyRequestCAS_FieldPath{sub.subPath.(UpdateAlertingPolicyRequestCAS_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateAlertingPolicyRequest_FieldSubPath{selector: UpdateAlertingPolicyRequest_FieldPathSelectorCas, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

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

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

func (fieldMask *UpdateAlertingPolicyRequest_FieldMask) AppendPath(path UpdateAlertingPolicyRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *UpdateAlertingPolicyRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*UpdateAlertingPolicyRequest), source.(*UpdateAlertingPolicyRequest))
}

func (fieldMask *UpdateAlertingPolicyRequest_FieldMask) Project(source *UpdateAlertingPolicyRequest) *UpdateAlertingPolicyRequest {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &UpdateAlertingPolicyRequest{}
	alertingPolicyMask := &alerting_policy.AlertingPolicy_FieldMask{}
	wholeAlertingPolicyAccepted := false
	casMask := &UpdateAlertingPolicyRequest_CAS_FieldMask{}
	wholeCasAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *UpdateAlertingPolicyRequest_FieldTerminalPath:
			switch tp.selector {
			case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
				result.AlertingPolicy = source.AlertingPolicy
				wholeAlertingPolicyAccepted = true
			case UpdateAlertingPolicyRequest_FieldPathSelectorUpdateMask:
				result.UpdateMask = source.UpdateMask
			case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
				result.Cas = source.Cas
				wholeCasAccepted = true
			}
		case *UpdateAlertingPolicyRequest_FieldSubPath:
			switch tp.selector {
			case UpdateAlertingPolicyRequest_FieldPathSelectorAlertingPolicy:
				alertingPolicyMask.AppendPath(tp.subPath.(alerting_policy.AlertingPolicy_FieldPath))
			case UpdateAlertingPolicyRequest_FieldPathSelectorCas:
				casMask.AppendPath(tp.subPath.(UpdateAlertingPolicyRequestCAS_FieldPath))
			}
		}
	}
	if wholeAlertingPolicyAccepted == false && len(alertingPolicyMask.Paths) > 0 {
		result.AlertingPolicy = alertingPolicyMask.Project(source.GetAlertingPolicy())
	}
	if wholeCasAccepted == false && len(casMask.Paths) > 0 {
		result.Cas = casMask.Project(source.GetCas())
	}
	return result
}

func (fieldMask *UpdateAlertingPolicyRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*UpdateAlertingPolicyRequest))
}

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

type UpdateAlertingPolicyRequest_CAS_FieldMask struct {
	Paths []UpdateAlertingPolicyRequestCAS_FieldPath
}

func FullUpdateAlertingPolicyRequest_CAS_FieldMask() *UpdateAlertingPolicyRequest_CAS_FieldMask {
	res := &UpdateAlertingPolicyRequest_CAS_FieldMask{}
	res.Paths = append(res.Paths, &UpdateAlertingPolicyRequestCAS_FieldTerminalPath{selector: UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState})
	res.Paths = append(res.Paths, &UpdateAlertingPolicyRequestCAS_FieldTerminalPath{selector: UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *UpdateAlertingPolicyRequest_CAS_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *UpdateAlertingPolicyRequest_CAS_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseUpdateAlertingPolicyRequestCAS_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *UpdateAlertingPolicyRequest_CAS_FieldMask) ProtoMessage() {}

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

func (fieldMask *UpdateAlertingPolicyRequest_CAS_FieldMask) Subtract(other *UpdateAlertingPolicyRequest_CAS_FieldMask) *UpdateAlertingPolicyRequest_CAS_FieldMask {
	result := &UpdateAlertingPolicyRequest_CAS_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[UpdateAlertingPolicyRequestCAS_FieldPathSelector]gotenobject.FieldMask{
		UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState: &alerting_policy.AlertingPolicy_FieldMask{},
	}
	mySubMasks := map[UpdateAlertingPolicyRequestCAS_FieldPathSelector]gotenobject.FieldMask{
		UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState: &alerting_policy.AlertingPolicy_FieldMask{},
	}

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

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *UpdateAlertingPolicyRequest_CAS_FieldMask) FilterInputFields() *UpdateAlertingPolicyRequest_CAS_FieldMask {
	result := &UpdateAlertingPolicyRequest_CAS_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
			if _, ok := path.(*UpdateAlertingPolicyRequestCAS_FieldTerminalPath); ok {
				for _, subpath := range alerting_policy.FullAlertingPolicy_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateAlertingPolicyRequestCAS_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*UpdateAlertingPolicyRequestCAS_FieldSubPath); ok {
				selectedMask := &alerting_policy.AlertingPolicy_FieldMask{
					Paths: []alerting_policy.AlertingPolicy_FieldPath{sub.subPath.(alerting_policy.AlertingPolicy_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateAlertingPolicyRequestCAS_FieldSubPath{selector: UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

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

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

func (fieldMask *UpdateAlertingPolicyRequest_CAS_FieldMask) AppendPath(path UpdateAlertingPolicyRequestCAS_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *UpdateAlertingPolicyRequest_CAS_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*UpdateAlertingPolicyRequest_CAS), source.(*UpdateAlertingPolicyRequest_CAS))
}

func (fieldMask *UpdateAlertingPolicyRequest_CAS_FieldMask) Project(source *UpdateAlertingPolicyRequest_CAS) *UpdateAlertingPolicyRequest_CAS {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &UpdateAlertingPolicyRequest_CAS{}
	conditionalStateMask := &alerting_policy.AlertingPolicy_FieldMask{}
	wholeConditionalStateAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *UpdateAlertingPolicyRequestCAS_FieldTerminalPath:
			switch tp.selector {
			case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
				result.ConditionalState = source.ConditionalState
				wholeConditionalStateAccepted = true
			case UpdateAlertingPolicyRequestCAS_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			}
		case *UpdateAlertingPolicyRequestCAS_FieldSubPath:
			switch tp.selector {
			case UpdateAlertingPolicyRequestCAS_FieldPathSelectorConditionalState:
				conditionalStateMask.AppendPath(tp.subPath.(alerting_policy.AlertingPolicy_FieldPath))
			}
		}
	}
	if wholeConditionalStateAccepted == false && len(conditionalStateMask.Paths) > 0 {
		result.ConditionalState = conditionalStateMask.Project(source.GetConditionalState())
	}
	return result
}

func (fieldMask *UpdateAlertingPolicyRequest_CAS_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*UpdateAlertingPolicyRequest_CAS))
}

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

type DeleteAlertingPolicyRequest_FieldMask struct {
	Paths []DeleteAlertingPolicyRequest_FieldPath
}

func FullDeleteAlertingPolicyRequest_FieldMask() *DeleteAlertingPolicyRequest_FieldMask {
	res := &DeleteAlertingPolicyRequest_FieldMask{}
	res.Paths = append(res.Paths, &DeleteAlertingPolicyRequest_FieldTerminalPath{selector: DeleteAlertingPolicyRequest_FieldPathSelectorName})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *DeleteAlertingPolicyRequest_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *DeleteAlertingPolicyRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseDeleteAlertingPolicyRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *DeleteAlertingPolicyRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *DeleteAlertingPolicyRequest_FieldMask) AppendPath(path DeleteAlertingPolicyRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *DeleteAlertingPolicyRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*DeleteAlertingPolicyRequest), source.(*DeleteAlertingPolicyRequest))
}

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

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

func (fieldMask *DeleteAlertingPolicyRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*DeleteAlertingPolicyRequest))
}

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

type SearchAlertingPoliciesRequest_FieldMask struct {
	Paths []SearchAlertingPoliciesRequest_FieldPath
}

func FullSearchAlertingPoliciesRequest_FieldMask() *SearchAlertingPoliciesRequest_FieldMask {
	res := &SearchAlertingPoliciesRequest_FieldMask{}
	res.Paths = append(res.Paths, &SearchAlertingPoliciesRequest_FieldTerminalPath{selector: SearchAlertingPoliciesRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesRequest_FieldTerminalPath{selector: SearchAlertingPoliciesRequest_FieldPathSelectorPageSize})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesRequest_FieldTerminalPath{selector: SearchAlertingPoliciesRequest_FieldPathSelectorPageToken})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesRequest_FieldTerminalPath{selector: SearchAlertingPoliciesRequest_FieldPathSelectorOrderBy})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesRequest_FieldTerminalPath{selector: SearchAlertingPoliciesRequest_FieldPathSelectorFilter})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesRequest_FieldTerminalPath{selector: SearchAlertingPoliciesRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesRequest_FieldTerminalPath{selector: SearchAlertingPoliciesRequest_FieldPathSelectorView})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesRequest_FieldTerminalPath{selector: SearchAlertingPoliciesRequest_FieldPathSelectorPhrase})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *SearchAlertingPoliciesRequest_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *SearchAlertingPoliciesRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseSearchAlertingPoliciesRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *SearchAlertingPoliciesRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fieldMask *SearchAlertingPoliciesRequest_FieldMask) AppendPath(path SearchAlertingPoliciesRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *SearchAlertingPoliciesRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*SearchAlertingPoliciesRequest), source.(*SearchAlertingPoliciesRequest))
}

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *SearchAlertingPoliciesRequest_FieldTerminalPath:
			switch tp.selector {
			case SearchAlertingPoliciesRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case SearchAlertingPoliciesRequest_FieldPathSelectorPageSize:
				result.PageSize = source.PageSize
			case SearchAlertingPoliciesRequest_FieldPathSelectorPageToken:
				result.PageToken = source.PageToken
			case SearchAlertingPoliciesRequest_FieldPathSelectorOrderBy:
				result.OrderBy = source.OrderBy
			case SearchAlertingPoliciesRequest_FieldPathSelectorFilter:
				result.Filter = source.Filter
			case SearchAlertingPoliciesRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case SearchAlertingPoliciesRequest_FieldPathSelectorView:
				result.View = source.View
			case SearchAlertingPoliciesRequest_FieldPathSelectorPhrase:
				result.Phrase = source.Phrase
			}
		}
	}
	return result
}

func (fieldMask *SearchAlertingPoliciesRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*SearchAlertingPoliciesRequest))
}

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

type SearchAlertingPoliciesResponse_FieldMask struct {
	Paths []SearchAlertingPoliciesResponse_FieldPath
}

func FullSearchAlertingPoliciesResponse_FieldMask() *SearchAlertingPoliciesResponse_FieldMask {
	res := &SearchAlertingPoliciesResponse_FieldMask{}
	res.Paths = append(res.Paths, &SearchAlertingPoliciesResponse_FieldTerminalPath{selector: SearchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesResponse_FieldTerminalPath{selector: SearchAlertingPoliciesResponse_FieldPathSelectorPrevPageToken})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesResponse_FieldTerminalPath{selector: SearchAlertingPoliciesResponse_FieldPathSelectorNextPageToken})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesResponse_FieldTerminalPath{selector: SearchAlertingPoliciesResponse_FieldPathSelectorCurrentOffset})
	res.Paths = append(res.Paths, &SearchAlertingPoliciesResponse_FieldTerminalPath{selector: SearchAlertingPoliciesResponse_FieldPathSelectorTotalResultsCount})
	return res
}

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

// firestore encoding/decoding integration
func (fieldMask *SearchAlertingPoliciesResponse_FieldMask) EncodeFirestore() (*firestorepb.Value, error) {
	if fieldMask == nil {
		return &firestorepb.Value{ValueType: &firestorepb.Value_NullValue{}}, nil
	}
	arrayValues := make([]*firestorepb.Value, 0, len(fieldMask.Paths))
	for _, path := range fieldMask.GetPaths() {
		arrayValues = append(arrayValues, &firestorepb.Value{ValueType: &firestorepb.Value_StringValue{StringValue: path.String()}})
	}
	return &firestorepb.Value{
		ValueType: &firestorepb.Value_ArrayValue{ArrayValue: &firestorepb.ArrayValue{Values: arrayValues}},
	}, nil
}

func (fieldMask *SearchAlertingPoliciesResponse_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseSearchAlertingPoliciesResponse_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *SearchAlertingPoliciesResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *SearchAlertingPoliciesResponse_FieldMask) Subtract(other *SearchAlertingPoliciesResponse_FieldMask) *SearchAlertingPoliciesResponse_FieldMask {
	result := &SearchAlertingPoliciesResponse_FieldMask{}
	removedSelectors := make([]bool, 5)
	otherSubMasks := map[SearchAlertingPoliciesResponse_FieldPathSelector]gotenobject.FieldMask{
		SearchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies: &alerting_policy.AlertingPolicy_FieldMask{},
	}
	mySubMasks := map[SearchAlertingPoliciesResponse_FieldPathSelector]gotenobject.FieldMask{
		SearchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies: &alerting_policy.AlertingPolicy_FieldMask{},
	}

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

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *SearchAlertingPoliciesResponse_FieldMask) FilterInputFields() *SearchAlertingPoliciesResponse_FieldMask {
	result := &SearchAlertingPoliciesResponse_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case SearchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
			if _, ok := path.(*SearchAlertingPoliciesResponse_FieldTerminalPath); ok {
				for _, subpath := range alerting_policy.FullAlertingPolicy_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &SearchAlertingPoliciesResponse_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*SearchAlertingPoliciesResponse_FieldSubPath); ok {
				selectedMask := &alerting_policy.AlertingPolicy_FieldMask{
					Paths: []alerting_policy.AlertingPolicy_FieldPath{sub.subPath.(alerting_policy.AlertingPolicy_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &SearchAlertingPoliciesResponse_FieldSubPath{selector: SearchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

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

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

func (fieldMask *SearchAlertingPoliciesResponse_FieldMask) AppendPath(path SearchAlertingPoliciesResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

func (fieldMask *SearchAlertingPoliciesResponse_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
	fieldMask.Set(target.(*SearchAlertingPoliciesResponse), source.(*SearchAlertingPoliciesResponse))
}

func (fieldMask *SearchAlertingPoliciesResponse_FieldMask) Project(source *SearchAlertingPoliciesResponse) *SearchAlertingPoliciesResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &SearchAlertingPoliciesResponse{}
	alertingPoliciesMask := &alerting_policy.AlertingPolicy_FieldMask{}
	wholeAlertingPoliciesAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *SearchAlertingPoliciesResponse_FieldTerminalPath:
			switch tp.selector {
			case SearchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
				result.AlertingPolicies = source.AlertingPolicies
				wholeAlertingPoliciesAccepted = true
			case SearchAlertingPoliciesResponse_FieldPathSelectorPrevPageToken:
				result.PrevPageToken = source.PrevPageToken
			case SearchAlertingPoliciesResponse_FieldPathSelectorNextPageToken:
				result.NextPageToken = source.NextPageToken
			case SearchAlertingPoliciesResponse_FieldPathSelectorCurrentOffset:
				result.CurrentOffset = source.CurrentOffset
			case SearchAlertingPoliciesResponse_FieldPathSelectorTotalResultsCount:
				result.TotalResultsCount = source.TotalResultsCount
			}
		case *SearchAlertingPoliciesResponse_FieldSubPath:
			switch tp.selector {
			case SearchAlertingPoliciesResponse_FieldPathSelectorAlertingPolicies:
				alertingPoliciesMask.AppendPath(tp.subPath.(alerting_policy.AlertingPolicy_FieldPath))
			}
		}
	}
	if wholeAlertingPoliciesAccepted == false && len(alertingPoliciesMask.Paths) > 0 {
		for _, sourceItem := range source.GetAlertingPolicies() {
			result.AlertingPolicies = append(result.AlertingPolicies, alertingPoliciesMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *SearchAlertingPoliciesResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*SearchAlertingPoliciesResponse))
}

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