resource_change_log_custom.pb.fieldmask.go

// Code generated by protoc-gen-goten-object
// File: edgelq/audit/proto/v1alpha/resource_change_log_custom.proto
// DO NOT EDIT!!!

package resource_change_log_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 (
	audit_common "github.com/cloudwan/edgelq-sdk/audit/common/v1alpha"
	resource_change_log "github.com/cloudwan/edgelq-sdk/audit/resources/v1alpha/resource_change_log"
	rpc "github.com/cloudwan/edgelq-sdk/common/rpc"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha/project"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
)

// 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 (
	_ = &audit_common.Authentication{}
	_ = &resource_change_log.ResourceChangeLog{}
	_ = &rpc.Status{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &timestamp.Timestamp{}
)

type ListResourceChangeLogsRequest_FieldMask struct {
	Paths []ListResourceChangeLogsRequest_FieldPath
}

func FullListResourceChangeLogsRequest_FieldMask() *ListResourceChangeLogsRequest_FieldMask {
	res := &ListResourceChangeLogsRequest_FieldMask{}
	res.Paths = append(res.Paths, &ListResourceChangeLogsRequest_FieldTerminalPath{selector: ListResourceChangeLogsRequest_FieldPathSelectorParents})
	res.Paths = append(res.Paths, &ListResourceChangeLogsRequest_FieldTerminalPath{selector: ListResourceChangeLogsRequest_FieldPathSelectorFilter})
	res.Paths = append(res.Paths, &ListResourceChangeLogsRequest_FieldTerminalPath{selector: ListResourceChangeLogsRequest_FieldPathSelectorInterval})
	res.Paths = append(res.Paths, &ListResourceChangeLogsRequest_FieldTerminalPath{selector: ListResourceChangeLogsRequest_FieldPathSelectorPageSize})
	res.Paths = append(res.Paths, &ListResourceChangeLogsRequest_FieldTerminalPath{selector: ListResourceChangeLogsRequest_FieldPathSelectorPageToken})
	return res
}

func (fieldMask *ListResourceChangeLogsRequest_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 *ListResourceChangeLogsRequest_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 *ListResourceChangeLogsRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseListResourceChangeLogsRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *ListResourceChangeLogsRequest_FieldMask) ProtoMessage() {}

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

func (fieldMask *ListResourceChangeLogsRequest_FieldMask) Subtract(other *ListResourceChangeLogsRequest_FieldMask) *ListResourceChangeLogsRequest_FieldMask {
	result := &ListResourceChangeLogsRequest_FieldMask{}
	removedSelectors := make([]bool, 5)
	otherSubMasks := map[ListResourceChangeLogsRequest_FieldPathSelector]gotenobject.FieldMask{
		ListResourceChangeLogsRequest_FieldPathSelectorInterval: &audit_common.TimeInterval_FieldMask{},
	}
	mySubMasks := map[ListResourceChangeLogsRequest_FieldPathSelector]gotenobject.FieldMask{
		ListResourceChangeLogsRequest_FieldPathSelectorInterval: &audit_common.TimeInterval_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *ListResourceChangeLogsRequest_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *ListResourceChangeLogsRequest_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.(*ListResourceChangeLogsRequest_FieldTerminalPath); ok {
					switch tp.selector {
					case ListResourceChangeLogsRequest_FieldPathSelectorInterval:
						mySubMasks[ListResourceChangeLogsRequest_FieldPathSelectorInterval] = audit_common.FullTimeInterval_FieldMask()
					}
				} else if tp, ok := path.(*ListResourceChangeLogsRequest_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, &ListResourceChangeLogsRequest_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

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

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

func (fieldMask *ListResourceChangeLogsRequest_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 *ListResourceChangeLogsRequest_FieldMask) AppendPath(path ListResourceChangeLogsRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *ListResourceChangeLogsRequest_FieldMask) Project(source *ListResourceChangeLogsRequest) *ListResourceChangeLogsRequest {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &ListResourceChangeLogsRequest{}
	intervalMask := &audit_common.TimeInterval_FieldMask{}
	wholeIntervalAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *ListResourceChangeLogsRequest_FieldTerminalPath:
			switch tp.selector {
			case ListResourceChangeLogsRequest_FieldPathSelectorParents:
				result.Parents = source.Parents
			case ListResourceChangeLogsRequest_FieldPathSelectorFilter:
				result.Filter = source.Filter
			case ListResourceChangeLogsRequest_FieldPathSelectorInterval:
				result.Interval = source.Interval
				wholeIntervalAccepted = true
			case ListResourceChangeLogsRequest_FieldPathSelectorPageSize:
				result.PageSize = source.PageSize
			case ListResourceChangeLogsRequest_FieldPathSelectorPageToken:
				result.PageToken = source.PageToken
			}
		case *ListResourceChangeLogsRequest_FieldSubPath:
			switch tp.selector {
			case ListResourceChangeLogsRequest_FieldPathSelectorInterval:
				intervalMask.AppendPath(tp.subPath.(audit_common.TimeInterval_FieldPath))
			}
		}
	}
	if wholeIntervalAccepted == false && len(intervalMask.Paths) > 0 {
		result.Interval = intervalMask.Project(source.GetInterval())
	}
	return result
}

func (fieldMask *ListResourceChangeLogsRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*ListResourceChangeLogsRequest))
}

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

type ListResourceChangeLogsResponse_FieldMask struct {
	Paths []ListResourceChangeLogsResponse_FieldPath
}

func FullListResourceChangeLogsResponse_FieldMask() *ListResourceChangeLogsResponse_FieldMask {
	res := &ListResourceChangeLogsResponse_FieldMask{}
	res.Paths = append(res.Paths, &ListResourceChangeLogsResponse_FieldTerminalPath{selector: ListResourceChangeLogsResponse_FieldPathSelectorResourceChangeLogs})
	res.Paths = append(res.Paths, &ListResourceChangeLogsResponse_FieldTerminalPath{selector: ListResourceChangeLogsResponse_FieldPathSelectorNextPageToken})
	res.Paths = append(res.Paths, &ListResourceChangeLogsResponse_FieldTerminalPath{selector: ListResourceChangeLogsResponse_FieldPathSelectorExecutionErrors})
	return res
}

func (fieldMask *ListResourceChangeLogsResponse_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 *ListResourceChangeLogsResponse_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 *ListResourceChangeLogsResponse_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseListResourceChangeLogsResponse_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *ListResourceChangeLogsResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *ListResourceChangeLogsResponse_FieldMask) Subtract(other *ListResourceChangeLogsResponse_FieldMask) *ListResourceChangeLogsResponse_FieldMask {
	result := &ListResourceChangeLogsResponse_FieldMask{}
	removedSelectors := make([]bool, 3)
	otherSubMasks := map[ListResourceChangeLogsResponse_FieldPathSelector]gotenobject.FieldMask{
		ListResourceChangeLogsResponse_FieldPathSelectorResourceChangeLogs: &resource_change_log.ResourceChangeLog_FieldMask{},
		ListResourceChangeLogsResponse_FieldPathSelectorExecutionErrors:    &rpc.Status_FieldMask{},
	}
	mySubMasks := map[ListResourceChangeLogsResponse_FieldPathSelector]gotenobject.FieldMask{
		ListResourceChangeLogsResponse_FieldPathSelectorResourceChangeLogs: &resource_change_log.ResourceChangeLog_FieldMask{},
		ListResourceChangeLogsResponse_FieldPathSelectorExecutionErrors:    &rpc.Status_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *ListResourceChangeLogsResponse_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *ListResourceChangeLogsResponse_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.(*ListResourceChangeLogsResponse_FieldTerminalPath); ok {
					switch tp.selector {
					case ListResourceChangeLogsResponse_FieldPathSelectorResourceChangeLogs:
						mySubMasks[ListResourceChangeLogsResponse_FieldPathSelectorResourceChangeLogs] = resource_change_log.FullResourceChangeLog_FieldMask()
					case ListResourceChangeLogsResponse_FieldPathSelectorExecutionErrors:
						mySubMasks[ListResourceChangeLogsResponse_FieldPathSelectorExecutionErrors] = rpc.FullStatus_FieldMask()
					}
				} else if tp, ok := path.(*ListResourceChangeLogsResponse_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, &ListResourceChangeLogsResponse_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

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

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

func (fieldMask *ListResourceChangeLogsResponse_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 *ListResourceChangeLogsResponse_FieldMask) AppendPath(path ListResourceChangeLogsResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *ListResourceChangeLogsResponse_FieldMask) Project(source *ListResourceChangeLogsResponse) *ListResourceChangeLogsResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &ListResourceChangeLogsResponse{}
	resourceChangeLogsMask := &resource_change_log.ResourceChangeLog_FieldMask{}
	wholeResourceChangeLogsAccepted := false
	executionErrorsMask := &rpc.Status_FieldMask{}
	wholeExecutionErrorsAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *ListResourceChangeLogsResponse_FieldTerminalPath:
			switch tp.selector {
			case ListResourceChangeLogsResponse_FieldPathSelectorResourceChangeLogs:
				result.ResourceChangeLogs = source.ResourceChangeLogs
				wholeResourceChangeLogsAccepted = true
			case ListResourceChangeLogsResponse_FieldPathSelectorNextPageToken:
				result.NextPageToken = source.NextPageToken
			case ListResourceChangeLogsResponse_FieldPathSelectorExecutionErrors:
				result.ExecutionErrors = source.ExecutionErrors
				wholeExecutionErrorsAccepted = true
			}
		case *ListResourceChangeLogsResponse_FieldSubPath:
			switch tp.selector {
			case ListResourceChangeLogsResponse_FieldPathSelectorResourceChangeLogs:
				resourceChangeLogsMask.AppendPath(tp.subPath.(resource_change_log.ResourceChangeLog_FieldPath))
			case ListResourceChangeLogsResponse_FieldPathSelectorExecutionErrors:
				executionErrorsMask.AppendPath(tp.subPath.(rpc.Status_FieldPath))
			}
		}
	}
	if wholeResourceChangeLogsAccepted == false && len(resourceChangeLogsMask.Paths) > 0 {
		for _, sourceItem := range source.GetResourceChangeLogs() {
			result.ResourceChangeLogs = append(result.ResourceChangeLogs, resourceChangeLogsMask.Project(sourceItem))
		}
	}
	if wholeExecutionErrorsAccepted == false && len(executionErrorsMask.Paths) > 0 {
		for _, sourceItem := range source.GetExecutionErrors() {
			result.ExecutionErrors = append(result.ExecutionErrors, executionErrorsMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *ListResourceChangeLogsResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*ListResourceChangeLogsResponse))
}

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

type CreatePreCommittedResourceChangeLogsRequest_FieldMask struct {
	Paths []CreatePreCommittedResourceChangeLogsRequest_FieldPath
}

func FullCreatePreCommittedResourceChangeLogsRequest_FieldMask() *CreatePreCommittedResourceChangeLogsRequest_FieldMask {
	res := &CreatePreCommittedResourceChangeLogsRequest_FieldMask{}
	res.Paths = append(res.Paths, &CreatePreCommittedResourceChangeLogsRequest_FieldTerminalPath{selector: CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorRequestId})
	res.Paths = append(res.Paths, &CreatePreCommittedResourceChangeLogsRequest_FieldTerminalPath{selector: CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorTimestamp})
	res.Paths = append(res.Paths, &CreatePreCommittedResourceChangeLogsRequest_FieldTerminalPath{selector: CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorAuthentication})
	res.Paths = append(res.Paths, &CreatePreCommittedResourceChangeLogsRequest_FieldTerminalPath{selector: CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorService})
	res.Paths = append(res.Paths, &CreatePreCommittedResourceChangeLogsRequest_FieldTerminalPath{selector: CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorTransaction})
	res.Paths = append(res.Paths, &CreatePreCommittedResourceChangeLogsRequest_FieldTerminalPath{selector: CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorChanges})
	return res
}

func (fieldMask *CreatePreCommittedResourceChangeLogsRequest_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 *CreatePreCommittedResourceChangeLogsRequest_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 *CreatePreCommittedResourceChangeLogsRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseCreatePreCommittedResourceChangeLogsRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *CreatePreCommittedResourceChangeLogsRequest_FieldMask) ProtoMessage() {}

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

func (fieldMask *CreatePreCommittedResourceChangeLogsRequest_FieldMask) Subtract(other *CreatePreCommittedResourceChangeLogsRequest_FieldMask) *CreatePreCommittedResourceChangeLogsRequest_FieldMask {
	result := &CreatePreCommittedResourceChangeLogsRequest_FieldMask{}
	removedSelectors := make([]bool, 6)
	otherSubMasks := map[CreatePreCommittedResourceChangeLogsRequest_FieldPathSelector]gotenobject.FieldMask{
		CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorAuthentication: &audit_common.Authentication_FieldMask{},
		CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorService:        &audit_common.ServiceData_FieldMask{},
		CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorTransaction:    &resource_change_log.ResourceChangeLog_TransactionInfo_FieldMask{},
		CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorChanges:        &resource_change_log.ResourceChangeLog_ResourceChange_FieldMask{},
	}
	mySubMasks := map[CreatePreCommittedResourceChangeLogsRequest_FieldPathSelector]gotenobject.FieldMask{
		CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorAuthentication: &audit_common.Authentication_FieldMask{},
		CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorService:        &audit_common.ServiceData_FieldMask{},
		CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorTransaction:    &resource_change_log.ResourceChangeLog_TransactionInfo_FieldMask{},
		CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorChanges:        &resource_change_log.ResourceChangeLog_ResourceChange_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *CreatePreCommittedResourceChangeLogsRequest_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *CreatePreCommittedResourceChangeLogsRequest_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.(*CreatePreCommittedResourceChangeLogsRequest_FieldTerminalPath); ok {
					switch tp.selector {
					case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorAuthentication:
						mySubMasks[CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorAuthentication] = audit_common.FullAuthentication_FieldMask()
					case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorService:
						mySubMasks[CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorService] = audit_common.FullServiceData_FieldMask()
					case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorTransaction:
						mySubMasks[CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorTransaction] = resource_change_log.FullResourceChangeLog_TransactionInfo_FieldMask()
					case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorChanges:
						mySubMasks[CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorChanges] = resource_change_log.FullResourceChangeLog_ResourceChange_FieldMask()
					}
				} else if tp, ok := path.(*CreatePreCommittedResourceChangeLogsRequest_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, &CreatePreCommittedResourceChangeLogsRequest_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

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

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

func (fieldMask *CreatePreCommittedResourceChangeLogsRequest_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 *CreatePreCommittedResourceChangeLogsRequest_FieldMask) AppendPath(path CreatePreCommittedResourceChangeLogsRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *CreatePreCommittedResourceChangeLogsRequest_FieldMask) Project(source *CreatePreCommittedResourceChangeLogsRequest) *CreatePreCommittedResourceChangeLogsRequest {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &CreatePreCommittedResourceChangeLogsRequest{}
	authenticationMask := &audit_common.Authentication_FieldMask{}
	wholeAuthenticationAccepted := false
	serviceMask := &audit_common.ServiceData_FieldMask{}
	wholeServiceAccepted := false
	transactionMask := &resource_change_log.ResourceChangeLog_TransactionInfo_FieldMask{}
	wholeTransactionAccepted := false
	changesMask := &resource_change_log.ResourceChangeLog_ResourceChange_FieldMask{}
	wholeChangesAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *CreatePreCommittedResourceChangeLogsRequest_FieldTerminalPath:
			switch tp.selector {
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorRequestId:
				result.RequestId = source.RequestId
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorTimestamp:
				result.Timestamp = source.Timestamp
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorAuthentication:
				result.Authentication = source.Authentication
				wholeAuthenticationAccepted = true
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorService:
				result.Service = source.Service
				wholeServiceAccepted = true
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorTransaction:
				result.Transaction = source.Transaction
				wholeTransactionAccepted = true
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorChanges:
				result.Changes = source.Changes
				wholeChangesAccepted = true
			}
		case *CreatePreCommittedResourceChangeLogsRequest_FieldSubPath:
			switch tp.selector {
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorAuthentication:
				authenticationMask.AppendPath(tp.subPath.(audit_common.Authentication_FieldPath))
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorService:
				serviceMask.AppendPath(tp.subPath.(audit_common.ServiceData_FieldPath))
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorTransaction:
				transactionMask.AppendPath(tp.subPath.(resource_change_log.ResourceChangeLogTransactionInfo_FieldPath))
			case CreatePreCommittedResourceChangeLogsRequest_FieldPathSelectorChanges:
				changesMask.AppendPath(tp.subPath.(resource_change_log.ResourceChangeLogResourceChange_FieldPath))
			}
		}
	}
	if wholeAuthenticationAccepted == false && len(authenticationMask.Paths) > 0 {
		result.Authentication = authenticationMask.Project(source.GetAuthentication())
	}
	if wholeServiceAccepted == false && len(serviceMask.Paths) > 0 {
		result.Service = serviceMask.Project(source.GetService())
	}
	if wholeTransactionAccepted == false && len(transactionMask.Paths) > 0 {
		result.Transaction = transactionMask.Project(source.GetTransaction())
	}
	if wholeChangesAccepted == false && len(changesMask.Paths) > 0 {
		for _, sourceItem := range source.GetChanges() {
			result.Changes = append(result.Changes, changesMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *CreatePreCommittedResourceChangeLogsRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*CreatePreCommittedResourceChangeLogsRequest))
}

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

type CreatePreCommittedResourceChangeLogsResponse_FieldMask struct {
	Paths []CreatePreCommittedResourceChangeLogsResponse_FieldPath
}

func FullCreatePreCommittedResourceChangeLogsResponse_FieldMask() *CreatePreCommittedResourceChangeLogsResponse_FieldMask {
	res := &CreatePreCommittedResourceChangeLogsResponse_FieldMask{}
	res.Paths = append(res.Paths, &CreatePreCommittedResourceChangeLogsResponse_FieldTerminalPath{selector: CreatePreCommittedResourceChangeLogsResponse_FieldPathSelectorLogKeys})
	return res
}

func (fieldMask *CreatePreCommittedResourceChangeLogsResponse_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 *CreatePreCommittedResourceChangeLogsResponse_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 *CreatePreCommittedResourceChangeLogsResponse_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseCreatePreCommittedResourceChangeLogsResponse_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *CreatePreCommittedResourceChangeLogsResponse_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *CreatePreCommittedResourceChangeLogsResponse_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 *CreatePreCommittedResourceChangeLogsResponse_FieldMask) AppendPath(path CreatePreCommittedResourceChangeLogsResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *CreatePreCommittedResourceChangeLogsResponse_FieldTerminalPath:
			switch tp.selector {
			case CreatePreCommittedResourceChangeLogsResponse_FieldPathSelectorLogKeys:
				result.LogKeys = source.LogKeys
			}
		}
	}
	return result
}

func (fieldMask *CreatePreCommittedResourceChangeLogsResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*CreatePreCommittedResourceChangeLogsResponse))
}

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

type SetResourceChangeLogsCommitStateRequest_FieldMask struct {
	Paths []SetResourceChangeLogsCommitStateRequest_FieldPath
}

func FullSetResourceChangeLogsCommitStateRequest_FieldMask() *SetResourceChangeLogsCommitStateRequest_FieldMask {
	res := &SetResourceChangeLogsCommitStateRequest_FieldMask{}
	res.Paths = append(res.Paths, &SetResourceChangeLogsCommitStateRequest_FieldTerminalPath{selector: SetResourceChangeLogsCommitStateRequest_FieldPathSelectorLogKeys})
	res.Paths = append(res.Paths, &SetResourceChangeLogsCommitStateRequest_FieldTerminalPath{selector: SetResourceChangeLogsCommitStateRequest_FieldPathSelectorTimestamp})
	res.Paths = append(res.Paths, &SetResourceChangeLogsCommitStateRequest_FieldTerminalPath{selector: SetResourceChangeLogsCommitStateRequest_FieldPathSelectorTxResult})
	return res
}

func (fieldMask *SetResourceChangeLogsCommitStateRequest_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 *SetResourceChangeLogsCommitStateRequest_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 *SetResourceChangeLogsCommitStateRequest_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseSetResourceChangeLogsCommitStateRequest_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *SetResourceChangeLogsCommitStateRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *SetResourceChangeLogsCommitStateRequest_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 *SetResourceChangeLogsCommitStateRequest_FieldMask) AppendPath(path SetResourceChangeLogsCommitStateRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *SetResourceChangeLogsCommitStateRequest_FieldTerminalPath:
			switch tp.selector {
			case SetResourceChangeLogsCommitStateRequest_FieldPathSelectorLogKeys:
				result.LogKeys = source.LogKeys
			case SetResourceChangeLogsCommitStateRequest_FieldPathSelectorTimestamp:
				result.Timestamp = source.Timestamp
			case SetResourceChangeLogsCommitStateRequest_FieldPathSelectorTxResult:
				result.TxResult = source.TxResult
			}
		}
	}
	return result
}

func (fieldMask *SetResourceChangeLogsCommitStateRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*SetResourceChangeLogsCommitStateRequest))
}

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

type SetResourceChangeLogsCommitStateResponse_FieldMask struct {
	Paths []SetResourceChangeLogsCommitStateResponse_FieldPath
}

func FullSetResourceChangeLogsCommitStateResponse_FieldMask() *SetResourceChangeLogsCommitStateResponse_FieldMask {
	res := &SetResourceChangeLogsCommitStateResponse_FieldMask{}
	return res
}

func (fieldMask *SetResourceChangeLogsCommitStateResponse_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 *SetResourceChangeLogsCommitStateResponse_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 *SetResourceChangeLogsCommitStateResponse_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error {
	for _, value := range fpbv.GetArrayValue().GetValues() {
		parsedPath, err := ParseSetResourceChangeLogsCommitStateResponse_FieldPath(value.GetStringValue())
		if err != nil {
			return err
		}
		fieldMask.Paths = append(fieldMask.Paths, parsedPath)
	}
	return nil
}

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

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

func (fieldMask *SetResourceChangeLogsCommitStateResponse_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *SetResourceChangeLogsCommitStateResponse_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 *SetResourceChangeLogsCommitStateResponse_FieldMask) AppendPath(path SetResourceChangeLogsCommitStateResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

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

func (fieldMask *SetResourceChangeLogsCommitStateResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*SetResourceChangeLogsCommitStateResponse))
}

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