provisioning_approval_request_service.pb.fieldmask.go

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

package provisioning_approval_request_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 (
	provisioning_approval_request "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha/provisioning_approval_request"
	provisioning_policy "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha/provisioning_policy"
	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 (
	_ = &provisioning_approval_request.ProvisioningApprovalRequest{}
	_ = &provisioning_policy.ProvisioningPolicy{}
	_ = &empty.Empty{}
	_ = &field_mask.FieldMask{}
	_ = &timestamp.Timestamp{}
	_ = view.View(0)
	_ = watch_type.WatchType(0)
)

type GetProvisioningApprovalRequestRequest_FieldMask struct {
	Paths []GetProvisioningApprovalRequestRequest_FieldPath
}

func FullGetProvisioningApprovalRequestRequest_FieldMask() *GetProvisioningApprovalRequestRequest_FieldMask {
	res := &GetProvisioningApprovalRequestRequest_FieldMask{}
	res.Paths = append(res.Paths, &GetProvisioningApprovalRequestRequest_FieldTerminalPath{selector: GetProvisioningApprovalRequestRequest_FieldPathSelectorName})
	res.Paths = append(res.Paths, &GetProvisioningApprovalRequestRequest_FieldTerminalPath{selector: GetProvisioningApprovalRequestRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &GetProvisioningApprovalRequestRequest_FieldTerminalPath{selector: GetProvisioningApprovalRequestRequest_FieldPathSelectorView})
	return res
}

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

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

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

func (fieldMask *GetProvisioningApprovalRequestRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *GetProvisioningApprovalRequestRequest_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 *GetProvisioningApprovalRequestRequest_FieldMask) AppendPath(path GetProvisioningApprovalRequestRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *GetProvisioningApprovalRequestRequest_FieldTerminalPath:
			switch tp.selector {
			case GetProvisioningApprovalRequestRequest_FieldPathSelectorName:
				result.Name = source.Name
			case GetProvisioningApprovalRequestRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case GetProvisioningApprovalRequestRequest_FieldPathSelectorView:
				result.View = source.View
			}
		}
	}
	return result
}

func (fieldMask *GetProvisioningApprovalRequestRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*GetProvisioningApprovalRequestRequest))
}

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

type BatchGetProvisioningApprovalRequestsRequest_FieldMask struct {
	Paths []BatchGetProvisioningApprovalRequestsRequest_FieldPath
}

func FullBatchGetProvisioningApprovalRequestsRequest_FieldMask() *BatchGetProvisioningApprovalRequestsRequest_FieldMask {
	res := &BatchGetProvisioningApprovalRequestsRequest_FieldMask{}
	res.Paths = append(res.Paths, &BatchGetProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: BatchGetProvisioningApprovalRequestsRequest_FieldPathSelectorNames})
	res.Paths = append(res.Paths, &BatchGetProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: BatchGetProvisioningApprovalRequestsRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &BatchGetProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: BatchGetProvisioningApprovalRequestsRequest_FieldPathSelectorView})
	return res
}

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

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

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

func (fieldMask *BatchGetProvisioningApprovalRequestsRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *BatchGetProvisioningApprovalRequestsRequest_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 *BatchGetProvisioningApprovalRequestsRequest_FieldMask) AppendPath(path BatchGetProvisioningApprovalRequestsRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *BatchGetProvisioningApprovalRequestsRequest_FieldTerminalPath:
			switch tp.selector {
			case BatchGetProvisioningApprovalRequestsRequest_FieldPathSelectorNames:
				result.Names = source.Names
			case BatchGetProvisioningApprovalRequestsRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case BatchGetProvisioningApprovalRequestsRequest_FieldPathSelectorView:
				result.View = source.View
			}
		}
	}
	return result
}

func (fieldMask *BatchGetProvisioningApprovalRequestsRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*BatchGetProvisioningApprovalRequestsRequest))
}

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

type BatchGetProvisioningApprovalRequestsResponse_FieldMask struct {
	Paths []BatchGetProvisioningApprovalRequestsResponse_FieldPath
}

func FullBatchGetProvisioningApprovalRequestsResponse_FieldMask() *BatchGetProvisioningApprovalRequestsResponse_FieldMask {
	res := &BatchGetProvisioningApprovalRequestsResponse_FieldMask{}
	res.Paths = append(res.Paths, &BatchGetProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests})
	res.Paths = append(res.Paths, &BatchGetProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorMissing})
	return res
}

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

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

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

func (fieldMask *BatchGetProvisioningApprovalRequestsResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *BatchGetProvisioningApprovalRequestsResponse_FieldMask) Subtract(other *BatchGetProvisioningApprovalRequestsResponse_FieldMask) *BatchGetProvisioningApprovalRequestsResponse_FieldMask {
	result := &BatchGetProvisioningApprovalRequestsResponse_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[BatchGetProvisioningApprovalRequestsResponse_FieldPathSelector]gotenobject.FieldMask{
		BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
	}
	mySubMasks := map[BatchGetProvisioningApprovalRequestsResponse_FieldPathSelector]gotenobject.FieldMask{
		BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *BatchGetProvisioningApprovalRequestsResponse_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *BatchGetProvisioningApprovalRequestsResponse_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.(*BatchGetProvisioningApprovalRequestsResponse_FieldTerminalPath); ok {
					switch tp.selector {
					case BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests:
						mySubMasks[BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests] = provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask()
					}
				} else if tp, ok := path.(*BatchGetProvisioningApprovalRequestsResponse_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, &BatchGetProvisioningApprovalRequestsResponse_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *BatchGetProvisioningApprovalRequestsResponse_FieldMask) FilterInputFields() *BatchGetProvisioningApprovalRequestsResponse_FieldMask {
	result := &BatchGetProvisioningApprovalRequestsResponse_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests:
			if _, ok := path.(*BatchGetProvisioningApprovalRequestsResponse_FieldTerminalPath); ok {
				for _, subpath := range provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &BatchGetProvisioningApprovalRequestsResponse_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*BatchGetProvisioningApprovalRequestsResponse_FieldSubPath); ok {
				selectedMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{
					Paths: []provisioning_approval_request.ProvisioningApprovalRequest_FieldPath{sub.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &BatchGetProvisioningApprovalRequestsResponse_FieldSubPath{selector: BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *BatchGetProvisioningApprovalRequestsResponse_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 *BatchGetProvisioningApprovalRequestsResponse_FieldMask) AppendPath(path BatchGetProvisioningApprovalRequestsResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *BatchGetProvisioningApprovalRequestsResponse_FieldMask) Project(source *BatchGetProvisioningApprovalRequestsResponse) *BatchGetProvisioningApprovalRequestsResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &BatchGetProvisioningApprovalRequestsResponse{}
	provisioningApprovalRequestsMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{}
	wholeProvisioningApprovalRequestsAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *BatchGetProvisioningApprovalRequestsResponse_FieldTerminalPath:
			switch tp.selector {
			case BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests:
				result.ProvisioningApprovalRequests = source.ProvisioningApprovalRequests
				wholeProvisioningApprovalRequestsAccepted = true
			case BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorMissing:
				result.Missing = source.Missing
			}
		case *BatchGetProvisioningApprovalRequestsResponse_FieldSubPath:
			switch tp.selector {
			case BatchGetProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests:
				provisioningApprovalRequestsMask.AppendPath(tp.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath))
			}
		}
	}
	if wholeProvisioningApprovalRequestsAccepted == false && len(provisioningApprovalRequestsMask.Paths) > 0 {
		for _, sourceItem := range source.GetProvisioningApprovalRequests() {
			result.ProvisioningApprovalRequests = append(result.ProvisioningApprovalRequests, provisioningApprovalRequestsMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *BatchGetProvisioningApprovalRequestsResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*BatchGetProvisioningApprovalRequestsResponse))
}

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

type ListProvisioningApprovalRequestsRequest_FieldMask struct {
	Paths []ListProvisioningApprovalRequestsRequest_FieldPath
}

func FullListProvisioningApprovalRequestsRequest_FieldMask() *ListProvisioningApprovalRequestsRequest_FieldMask {
	res := &ListProvisioningApprovalRequestsRequest_FieldMask{}
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: ListProvisioningApprovalRequestsRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: ListProvisioningApprovalRequestsRequest_FieldPathSelectorPageSize})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: ListProvisioningApprovalRequestsRequest_FieldPathSelectorPageToken})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: ListProvisioningApprovalRequestsRequest_FieldPathSelectorOrderBy})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: ListProvisioningApprovalRequestsRequest_FieldPathSelectorFilter})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: ListProvisioningApprovalRequestsRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: ListProvisioningApprovalRequestsRequest_FieldPathSelectorView})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: ListProvisioningApprovalRequestsRequest_FieldPathSelectorIncludePagingInfo})
	return res
}

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

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

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

func (fieldMask *ListProvisioningApprovalRequestsRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *ListProvisioningApprovalRequestsRequest_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 *ListProvisioningApprovalRequestsRequest_FieldMask) AppendPath(path ListProvisioningApprovalRequestsRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *ListProvisioningApprovalRequestsRequest_FieldTerminalPath:
			switch tp.selector {
			case ListProvisioningApprovalRequestsRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case ListProvisioningApprovalRequestsRequest_FieldPathSelectorPageSize:
				result.PageSize = source.PageSize
			case ListProvisioningApprovalRequestsRequest_FieldPathSelectorPageToken:
				result.PageToken = source.PageToken
			case ListProvisioningApprovalRequestsRequest_FieldPathSelectorOrderBy:
				result.OrderBy = source.OrderBy
			case ListProvisioningApprovalRequestsRequest_FieldPathSelectorFilter:
				result.Filter = source.Filter
			case ListProvisioningApprovalRequestsRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case ListProvisioningApprovalRequestsRequest_FieldPathSelectorView:
				result.View = source.View
			case ListProvisioningApprovalRequestsRequest_FieldPathSelectorIncludePagingInfo:
				result.IncludePagingInfo = source.IncludePagingInfo
			}
		}
	}
	return result
}

func (fieldMask *ListProvisioningApprovalRequestsRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*ListProvisioningApprovalRequestsRequest))
}

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

type ListProvisioningApprovalRequestsResponse_FieldMask struct {
	Paths []ListProvisioningApprovalRequestsResponse_FieldPath
}

func FullListProvisioningApprovalRequestsResponse_FieldMask() *ListProvisioningApprovalRequestsResponse_FieldMask {
	res := &ListProvisioningApprovalRequestsResponse_FieldMask{}
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: ListProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: ListProvisioningApprovalRequestsResponse_FieldPathSelectorPrevPageToken})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: ListProvisioningApprovalRequestsResponse_FieldPathSelectorNextPageToken})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: ListProvisioningApprovalRequestsResponse_FieldPathSelectorCurrentOffset})
	res.Paths = append(res.Paths, &ListProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: ListProvisioningApprovalRequestsResponse_FieldPathSelectorTotalResultsCount})
	return res
}

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

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

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

func (fieldMask *ListProvisioningApprovalRequestsResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *ListProvisioningApprovalRequestsResponse_FieldMask) Subtract(other *ListProvisioningApprovalRequestsResponse_FieldMask) *ListProvisioningApprovalRequestsResponse_FieldMask {
	result := &ListProvisioningApprovalRequestsResponse_FieldMask{}
	removedSelectors := make([]bool, 5)
	otherSubMasks := map[ListProvisioningApprovalRequestsResponse_FieldPathSelector]gotenobject.FieldMask{
		ListProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
	}
	mySubMasks := map[ListProvisioningApprovalRequestsResponse_FieldPathSelector]gotenobject.FieldMask{
		ListProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *ListProvisioningApprovalRequestsResponse_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *ListProvisioningApprovalRequestsResponse_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.(*ListProvisioningApprovalRequestsResponse_FieldTerminalPath); ok {
					switch tp.selector {
					case ListProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests:
						mySubMasks[ListProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests] = provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask()
					}
				} else if tp, ok := path.(*ListProvisioningApprovalRequestsResponse_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, &ListProvisioningApprovalRequestsResponse_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *ListProvisioningApprovalRequestsResponse_FieldMask) FilterInputFields() *ListProvisioningApprovalRequestsResponse_FieldMask {
	result := &ListProvisioningApprovalRequestsResponse_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case ListProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests:
			if _, ok := path.(*ListProvisioningApprovalRequestsResponse_FieldTerminalPath); ok {
				for _, subpath := range provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &ListProvisioningApprovalRequestsResponse_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*ListProvisioningApprovalRequestsResponse_FieldSubPath); ok {
				selectedMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{
					Paths: []provisioning_approval_request.ProvisioningApprovalRequest_FieldPath{sub.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &ListProvisioningApprovalRequestsResponse_FieldSubPath{selector: ListProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *ListProvisioningApprovalRequestsResponse_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 *ListProvisioningApprovalRequestsResponse_FieldMask) AppendPath(path ListProvisioningApprovalRequestsResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *ListProvisioningApprovalRequestsResponse_FieldMask) Project(source *ListProvisioningApprovalRequestsResponse) *ListProvisioningApprovalRequestsResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &ListProvisioningApprovalRequestsResponse{}
	provisioningApprovalRequestsMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{}
	wholeProvisioningApprovalRequestsAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *ListProvisioningApprovalRequestsResponse_FieldTerminalPath:
			switch tp.selector {
			case ListProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests:
				result.ProvisioningApprovalRequests = source.ProvisioningApprovalRequests
				wholeProvisioningApprovalRequestsAccepted = true
			case ListProvisioningApprovalRequestsResponse_FieldPathSelectorPrevPageToken:
				result.PrevPageToken = source.PrevPageToken
			case ListProvisioningApprovalRequestsResponse_FieldPathSelectorNextPageToken:
				result.NextPageToken = source.NextPageToken
			case ListProvisioningApprovalRequestsResponse_FieldPathSelectorCurrentOffset:
				result.CurrentOffset = source.CurrentOffset
			case ListProvisioningApprovalRequestsResponse_FieldPathSelectorTotalResultsCount:
				result.TotalResultsCount = source.TotalResultsCount
			}
		case *ListProvisioningApprovalRequestsResponse_FieldSubPath:
			switch tp.selector {
			case ListProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequests:
				provisioningApprovalRequestsMask.AppendPath(tp.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath))
			}
		}
	}
	if wholeProvisioningApprovalRequestsAccepted == false && len(provisioningApprovalRequestsMask.Paths) > 0 {
		for _, sourceItem := range source.GetProvisioningApprovalRequests() {
			result.ProvisioningApprovalRequests = append(result.ProvisioningApprovalRequests, provisioningApprovalRequestsMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *ListProvisioningApprovalRequestsResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*ListProvisioningApprovalRequestsResponse))
}

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

type WatchProvisioningApprovalRequestRequest_FieldMask struct {
	Paths []WatchProvisioningApprovalRequestRequest_FieldPath
}

func FullWatchProvisioningApprovalRequestRequest_FieldMask() *WatchProvisioningApprovalRequestRequest_FieldMask {
	res := &WatchProvisioningApprovalRequestRequest_FieldMask{}
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestRequest_FieldPathSelectorName})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestRequest_FieldPathSelectorView})
	return res
}

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestRequest_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 *WatchProvisioningApprovalRequestRequest_FieldMask) AppendPath(path WatchProvisioningApprovalRequestRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchProvisioningApprovalRequestRequest_FieldTerminalPath:
			switch tp.selector {
			case WatchProvisioningApprovalRequestRequest_FieldPathSelectorName:
				result.Name = source.Name
			case WatchProvisioningApprovalRequestRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case WatchProvisioningApprovalRequestRequest_FieldPathSelectorView:
				result.View = source.View
			}
		}
	}
	return result
}

func (fieldMask *WatchProvisioningApprovalRequestRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchProvisioningApprovalRequestRequest))
}

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

type WatchProvisioningApprovalRequestResponse_FieldMask struct {
	Paths []WatchProvisioningApprovalRequestResponse_FieldPath
}

func FullWatchProvisioningApprovalRequestResponse_FieldMask() *WatchProvisioningApprovalRequestResponse_FieldMask {
	res := &WatchProvisioningApprovalRequestResponse_FieldMask{}
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestResponse_FieldTerminalPath{selector: WatchProvisioningApprovalRequestResponse_FieldPathSelectorChange})
	return res
}

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestResponse_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestResponse_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 *WatchProvisioningApprovalRequestResponse_FieldMask) AppendPath(path WatchProvisioningApprovalRequestResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchProvisioningApprovalRequestResponse))
}

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

type WatchProvisioningApprovalRequestsRequest_FieldMask struct {
	Paths []WatchProvisioningApprovalRequestsRequest_FieldPath
}

func FullWatchProvisioningApprovalRequestsRequest_FieldMask() *WatchProvisioningApprovalRequestsRequest_FieldMask {
	res := &WatchProvisioningApprovalRequestsRequest_FieldMask{}
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorType})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorPageSize})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorPageToken})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorOrderBy})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorResumeToken})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorStartingTime})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorFilter})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorView})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsRequest_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsRequest_FieldPathSelectorMaxChunkSize})
	return res
}

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestsRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestsRequest_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 *WatchProvisioningApprovalRequestsRequest_FieldMask) AppendPath(path WatchProvisioningApprovalRequestsRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchProvisioningApprovalRequestsRequest_FieldTerminalPath:
			switch tp.selector {
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorType:
				result.Type = source.Type
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorPageSize:
				result.PageSize = source.PageSize
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorPageToken:
				result.PageToken = source.PageToken
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorOrderBy:
				result.OrderBy = source.OrderBy
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorResumeToken:
				result.ResumeToken = source.ResumeToken
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorStartingTime:
				result.StartingTime = source.StartingTime
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorFilter:
				result.Filter = source.Filter
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorView:
				result.View = source.View
			case WatchProvisioningApprovalRequestsRequest_FieldPathSelectorMaxChunkSize:
				result.MaxChunkSize = source.MaxChunkSize
			}
		}
	}
	return result
}

func (fieldMask *WatchProvisioningApprovalRequestsRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchProvisioningApprovalRequestsRequest))
}

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

type WatchProvisioningApprovalRequestsResponse_FieldMask struct {
	Paths []WatchProvisioningApprovalRequestsResponse_FieldPath
}

func FullWatchProvisioningApprovalRequestsResponse_FieldMask() *WatchProvisioningApprovalRequestsResponse_FieldMask {
	res := &WatchProvisioningApprovalRequestsResponse_FieldMask{}
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequestChanges})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsResponse_FieldPathSelectorIsCurrent})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsResponse_FieldPathSelectorPageTokenChange})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsResponse_FieldPathSelectorResumeToken})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsResponse_FieldPathSelectorSnapshotSize})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsResponse_FieldPathSelectorIsSoftReset})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsResponse_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsResponse_FieldPathSelectorIsHardReset})
	return res
}

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestsResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *WatchProvisioningApprovalRequestsResponse_FieldMask) Subtract(other *WatchProvisioningApprovalRequestsResponse_FieldMask) *WatchProvisioningApprovalRequestsResponse_FieldMask {
	result := &WatchProvisioningApprovalRequestsResponse_FieldMask{}
	removedSelectors := make([]bool, 7)
	otherSubMasks := map[WatchProvisioningApprovalRequestsResponse_FieldPathSelector]gotenobject.FieldMask{
		WatchProvisioningApprovalRequestsResponse_FieldPathSelectorPageTokenChange: &WatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask{},
	}
	mySubMasks := map[WatchProvisioningApprovalRequestsResponse_FieldPathSelector]gotenobject.FieldMask{
		WatchProvisioningApprovalRequestsResponse_FieldPathSelectorPageTokenChange: &WatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *WatchProvisioningApprovalRequestsResponse_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *WatchProvisioningApprovalRequestsResponse_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.(*WatchProvisioningApprovalRequestsResponse_FieldTerminalPath); ok {
					switch tp.selector {
					case WatchProvisioningApprovalRequestsResponse_FieldPathSelectorPageTokenChange:
						mySubMasks[WatchProvisioningApprovalRequestsResponse_FieldPathSelectorPageTokenChange] = FullWatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask()
					}
				} else if tp, ok := path.(*WatchProvisioningApprovalRequestsResponse_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, &WatchProvisioningApprovalRequestsResponse_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

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

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

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

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestsResponse_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 *WatchProvisioningApprovalRequestsResponse_FieldMask) AppendPath(path WatchProvisioningApprovalRequestsResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestsResponse_FieldMask) Project(source *WatchProvisioningApprovalRequestsResponse) *WatchProvisioningApprovalRequestsResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &WatchProvisioningApprovalRequestsResponse{}
	pageTokenChangeMask := &WatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask{}
	wholePageTokenChangeAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchProvisioningApprovalRequestsResponse_FieldTerminalPath:
			switch tp.selector {
			case WatchProvisioningApprovalRequestsResponse_FieldPathSelectorProvisioningApprovalRequestChanges:
				result.ProvisioningApprovalRequestChanges = source.ProvisioningApprovalRequestChanges
			case WatchProvisioningApprovalRequestsResponse_FieldPathSelectorIsCurrent:
				result.IsCurrent = source.IsCurrent
			case WatchProvisioningApprovalRequestsResponse_FieldPathSelectorPageTokenChange:
				result.PageTokenChange = source.PageTokenChange
				wholePageTokenChangeAccepted = true
			case WatchProvisioningApprovalRequestsResponse_FieldPathSelectorResumeToken:
				result.ResumeToken = source.ResumeToken
			case WatchProvisioningApprovalRequestsResponse_FieldPathSelectorSnapshotSize:
				result.SnapshotSize = source.SnapshotSize
			case WatchProvisioningApprovalRequestsResponse_FieldPathSelectorIsSoftReset:
				result.IsSoftReset = source.IsSoftReset
			case WatchProvisioningApprovalRequestsResponse_FieldPathSelectorIsHardReset:
				result.IsHardReset = source.IsHardReset
			}
		case *WatchProvisioningApprovalRequestsResponse_FieldSubPath:
			switch tp.selector {
			case WatchProvisioningApprovalRequestsResponse_FieldPathSelectorPageTokenChange:
				pageTokenChangeMask.AppendPath(tp.subPath.(WatchProvisioningApprovalRequestsResponsePageTokenChange_FieldPath))
			}
		}
	}
	if wholePageTokenChangeAccepted == false && len(pageTokenChangeMask.Paths) > 0 {
		result.PageTokenChange = pageTokenChangeMask.Project(source.GetPageTokenChange())
	}
	return result
}

func (fieldMask *WatchProvisioningApprovalRequestsResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchProvisioningApprovalRequestsResponse))
}

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

type WatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask struct {
	Paths []WatchProvisioningApprovalRequestsResponsePageTokenChange_FieldPath
}

func FullWatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask() *WatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask {
	res := &WatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask{}
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsResponsePageTokenChange_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsResponsePageTokenChange_FieldPathSelectorPrevPageToken})
	res.Paths = append(res.Paths, &WatchProvisioningApprovalRequestsResponsePageTokenChange_FieldTerminalPath{selector: WatchProvisioningApprovalRequestsResponsePageTokenChange_FieldPathSelectorNextPageToken})
	return res
}

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask) ProtoMessage() {
}

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestsResponse_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 *WatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask) AppendPath(path WatchProvisioningApprovalRequestsResponsePageTokenChange_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

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

func (fieldMask *WatchProvisioningApprovalRequestsResponse_PageTokenChange_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchProvisioningApprovalRequestsResponse_PageTokenChange))
}

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

type CreateProvisioningApprovalRequestRequest_FieldMask struct {
	Paths []CreateProvisioningApprovalRequestRequest_FieldPath
}

func FullCreateProvisioningApprovalRequestRequest_FieldMask() *CreateProvisioningApprovalRequestRequest_FieldMask {
	res := &CreateProvisioningApprovalRequestRequest_FieldMask{}
	res.Paths = append(res.Paths, &CreateProvisioningApprovalRequestRequest_FieldTerminalPath{selector: CreateProvisioningApprovalRequestRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &CreateProvisioningApprovalRequestRequest_FieldTerminalPath{selector: CreateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest})
	return res
}

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

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

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

func (fieldMask *CreateProvisioningApprovalRequestRequest_FieldMask) ProtoMessage() {}

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

func (fieldMask *CreateProvisioningApprovalRequestRequest_FieldMask) Subtract(other *CreateProvisioningApprovalRequestRequest_FieldMask) *CreateProvisioningApprovalRequestRequest_FieldMask {
	result := &CreateProvisioningApprovalRequestRequest_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[CreateProvisioningApprovalRequestRequest_FieldPathSelector]gotenobject.FieldMask{
		CreateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
	}
	mySubMasks := map[CreateProvisioningApprovalRequestRequest_FieldPathSelector]gotenobject.FieldMask{
		CreateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *CreateProvisioningApprovalRequestRequest_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *CreateProvisioningApprovalRequestRequest_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.(*CreateProvisioningApprovalRequestRequest_FieldTerminalPath); ok {
					switch tp.selector {
					case CreateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest:
						mySubMasks[CreateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest] = provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask()
					}
				} else if tp, ok := path.(*CreateProvisioningApprovalRequestRequest_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, &CreateProvisioningApprovalRequestRequest_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *CreateProvisioningApprovalRequestRequest_FieldMask) FilterInputFields() *CreateProvisioningApprovalRequestRequest_FieldMask {
	result := &CreateProvisioningApprovalRequestRequest_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case CreateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest:
			if _, ok := path.(*CreateProvisioningApprovalRequestRequest_FieldTerminalPath); ok {
				for _, subpath := range provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &CreateProvisioningApprovalRequestRequest_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*CreateProvisioningApprovalRequestRequest_FieldSubPath); ok {
				selectedMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{
					Paths: []provisioning_approval_request.ProvisioningApprovalRequest_FieldPath{sub.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &CreateProvisioningApprovalRequestRequest_FieldSubPath{selector: CreateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *CreateProvisioningApprovalRequestRequest_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 *CreateProvisioningApprovalRequestRequest_FieldMask) AppendPath(path CreateProvisioningApprovalRequestRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *CreateProvisioningApprovalRequestRequest_FieldMask) Project(source *CreateProvisioningApprovalRequestRequest) *CreateProvisioningApprovalRequestRequest {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &CreateProvisioningApprovalRequestRequest{}
	provisioningApprovalRequestMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{}
	wholeProvisioningApprovalRequestAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *CreateProvisioningApprovalRequestRequest_FieldTerminalPath:
			switch tp.selector {
			case CreateProvisioningApprovalRequestRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case CreateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest:
				result.ProvisioningApprovalRequest = source.ProvisioningApprovalRequest
				wholeProvisioningApprovalRequestAccepted = true
			}
		case *CreateProvisioningApprovalRequestRequest_FieldSubPath:
			switch tp.selector {
			case CreateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest:
				provisioningApprovalRequestMask.AppendPath(tp.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath))
			}
		}
	}
	if wholeProvisioningApprovalRequestAccepted == false && len(provisioningApprovalRequestMask.Paths) > 0 {
		result.ProvisioningApprovalRequest = provisioningApprovalRequestMask.Project(source.GetProvisioningApprovalRequest())
	}
	return result
}

func (fieldMask *CreateProvisioningApprovalRequestRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*CreateProvisioningApprovalRequestRequest))
}

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

type UpdateProvisioningApprovalRequestRequest_FieldMask struct {
	Paths []UpdateProvisioningApprovalRequestRequest_FieldPath
}

func FullUpdateProvisioningApprovalRequestRequest_FieldMask() *UpdateProvisioningApprovalRequestRequest_FieldMask {
	res := &UpdateProvisioningApprovalRequestRequest_FieldMask{}
	res.Paths = append(res.Paths, &UpdateProvisioningApprovalRequestRequest_FieldTerminalPath{selector: UpdateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest})
	res.Paths = append(res.Paths, &UpdateProvisioningApprovalRequestRequest_FieldTerminalPath{selector: UpdateProvisioningApprovalRequestRequest_FieldPathSelectorUpdateMask})
	res.Paths = append(res.Paths, &UpdateProvisioningApprovalRequestRequest_FieldTerminalPath{selector: UpdateProvisioningApprovalRequestRequest_FieldPathSelectorCas})
	res.Paths = append(res.Paths, &UpdateProvisioningApprovalRequestRequest_FieldTerminalPath{selector: UpdateProvisioningApprovalRequestRequest_FieldPathSelectorAllowMissing})
	return res
}

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

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

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

func (fieldMask *UpdateProvisioningApprovalRequestRequest_FieldMask) ProtoMessage() {}

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

func (fieldMask *UpdateProvisioningApprovalRequestRequest_FieldMask) Subtract(other *UpdateProvisioningApprovalRequestRequest_FieldMask) *UpdateProvisioningApprovalRequestRequest_FieldMask {
	result := &UpdateProvisioningApprovalRequestRequest_FieldMask{}
	removedSelectors := make([]bool, 4)
	otherSubMasks := map[UpdateProvisioningApprovalRequestRequest_FieldPathSelector]gotenobject.FieldMask{
		UpdateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
		UpdateProvisioningApprovalRequestRequest_FieldPathSelectorCas:                         &UpdateProvisioningApprovalRequestRequest_CAS_FieldMask{},
	}
	mySubMasks := map[UpdateProvisioningApprovalRequestRequest_FieldPathSelector]gotenobject.FieldMask{
		UpdateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
		UpdateProvisioningApprovalRequestRequest_FieldPathSelectorCas:                         &UpdateProvisioningApprovalRequestRequest_CAS_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *UpdateProvisioningApprovalRequestRequest_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *UpdateProvisioningApprovalRequestRequest_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.(*UpdateProvisioningApprovalRequestRequest_FieldTerminalPath); ok {
					switch tp.selector {
					case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest:
						mySubMasks[UpdateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest] = provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask()
					case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorCas:
						mySubMasks[UpdateProvisioningApprovalRequestRequest_FieldPathSelectorCas] = FullUpdateProvisioningApprovalRequestRequest_CAS_FieldMask()
					}
				} else if tp, ok := path.(*UpdateProvisioningApprovalRequestRequest_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, &UpdateProvisioningApprovalRequestRequest_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *UpdateProvisioningApprovalRequestRequest_FieldMask) FilterInputFields() *UpdateProvisioningApprovalRequestRequest_FieldMask {
	result := &UpdateProvisioningApprovalRequestRequest_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest:
			if _, ok := path.(*UpdateProvisioningApprovalRequestRequest_FieldTerminalPath); ok {
				for _, subpath := range provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateProvisioningApprovalRequestRequest_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*UpdateProvisioningApprovalRequestRequest_FieldSubPath); ok {
				selectedMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{
					Paths: []provisioning_approval_request.ProvisioningApprovalRequest_FieldPath{sub.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateProvisioningApprovalRequestRequest_FieldSubPath{selector: UpdateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest, subPath: allowedPath})
				}
			}
		case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorCas:
			if _, ok := path.(*UpdateProvisioningApprovalRequestRequest_FieldTerminalPath); ok {
				for _, subpath := range FullUpdateProvisioningApprovalRequestRequest_CAS_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateProvisioningApprovalRequestRequest_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*UpdateProvisioningApprovalRequestRequest_FieldSubPath); ok {
				selectedMask := &UpdateProvisioningApprovalRequestRequest_CAS_FieldMask{
					Paths: []UpdateProvisioningApprovalRequestRequestCAS_FieldPath{sub.subPath.(UpdateProvisioningApprovalRequestRequestCAS_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateProvisioningApprovalRequestRequest_FieldSubPath{selector: UpdateProvisioningApprovalRequestRequest_FieldPathSelectorCas, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *UpdateProvisioningApprovalRequestRequest_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 *UpdateProvisioningApprovalRequestRequest_FieldMask) AppendPath(path UpdateProvisioningApprovalRequestRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *UpdateProvisioningApprovalRequestRequest_FieldMask) Project(source *UpdateProvisioningApprovalRequestRequest) *UpdateProvisioningApprovalRequestRequest {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &UpdateProvisioningApprovalRequestRequest{}
	provisioningApprovalRequestMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{}
	wholeProvisioningApprovalRequestAccepted := false
	casMask := &UpdateProvisioningApprovalRequestRequest_CAS_FieldMask{}
	wholeCasAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *UpdateProvisioningApprovalRequestRequest_FieldTerminalPath:
			switch tp.selector {
			case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest:
				result.ProvisioningApprovalRequest = source.ProvisioningApprovalRequest
				wholeProvisioningApprovalRequestAccepted = true
			case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorUpdateMask:
				result.UpdateMask = source.UpdateMask
			case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorCas:
				result.Cas = source.Cas
				wholeCasAccepted = true
			case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorAllowMissing:
				result.AllowMissing = source.AllowMissing
			}
		case *UpdateProvisioningApprovalRequestRequest_FieldSubPath:
			switch tp.selector {
			case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorProvisioningApprovalRequest:
				provisioningApprovalRequestMask.AppendPath(tp.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath))
			case UpdateProvisioningApprovalRequestRequest_FieldPathSelectorCas:
				casMask.AppendPath(tp.subPath.(UpdateProvisioningApprovalRequestRequestCAS_FieldPath))
			}
		}
	}
	if wholeProvisioningApprovalRequestAccepted == false && len(provisioningApprovalRequestMask.Paths) > 0 {
		result.ProvisioningApprovalRequest = provisioningApprovalRequestMask.Project(source.GetProvisioningApprovalRequest())
	}
	if wholeCasAccepted == false && len(casMask.Paths) > 0 {
		result.Cas = casMask.Project(source.GetCas())
	}
	return result
}

func (fieldMask *UpdateProvisioningApprovalRequestRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*UpdateProvisioningApprovalRequestRequest))
}

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

type UpdateProvisioningApprovalRequestRequest_CAS_FieldMask struct {
	Paths []UpdateProvisioningApprovalRequestRequestCAS_FieldPath
}

func FullUpdateProvisioningApprovalRequestRequest_CAS_FieldMask() *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask {
	res := &UpdateProvisioningApprovalRequestRequest_CAS_FieldMask{}
	res.Paths = append(res.Paths, &UpdateProvisioningApprovalRequestRequestCAS_FieldTerminalPath{selector: UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorConditionalState})
	res.Paths = append(res.Paths, &UpdateProvisioningApprovalRequestRequestCAS_FieldTerminalPath{selector: UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorFieldMask})
	return res
}

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

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

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

func (fieldMask *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask) ProtoMessage() {}

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

func (fieldMask *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask) Subtract(other *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask) *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask {
	result := &UpdateProvisioningApprovalRequestRequest_CAS_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelector]gotenobject.FieldMask{
		UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorConditionalState: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
	}
	mySubMasks := map[UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelector]gotenobject.FieldMask{
		UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorConditionalState: &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *UpdateProvisioningApprovalRequestRequestCAS_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *UpdateProvisioningApprovalRequestRequestCAS_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.(*UpdateProvisioningApprovalRequestRequestCAS_FieldTerminalPath); ok {
					switch tp.selector {
					case UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorConditionalState:
						mySubMasks[UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorConditionalState] = provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask()
					}
				} else if tp, ok := path.(*UpdateProvisioningApprovalRequestRequestCAS_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, &UpdateProvisioningApprovalRequestRequestCAS_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask) FilterInputFields() *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask {
	result := &UpdateProvisioningApprovalRequestRequest_CAS_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorConditionalState:
			if _, ok := path.(*UpdateProvisioningApprovalRequestRequestCAS_FieldTerminalPath); ok {
				for _, subpath := range provisioning_approval_request.FullProvisioningApprovalRequest_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateProvisioningApprovalRequestRequestCAS_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*UpdateProvisioningApprovalRequestRequestCAS_FieldSubPath); ok {
				selectedMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{
					Paths: []provisioning_approval_request.ProvisioningApprovalRequest_FieldPath{sub.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateProvisioningApprovalRequestRequestCAS_FieldSubPath{selector: UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorConditionalState, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *UpdateProvisioningApprovalRequestRequest_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 *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask) AppendPath(path UpdateProvisioningApprovalRequestRequestCAS_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask) Project(source *UpdateProvisioningApprovalRequestRequest_CAS) *UpdateProvisioningApprovalRequestRequest_CAS {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &UpdateProvisioningApprovalRequestRequest_CAS{}
	conditionalStateMask := &provisioning_approval_request.ProvisioningApprovalRequest_FieldMask{}
	wholeConditionalStateAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *UpdateProvisioningApprovalRequestRequestCAS_FieldTerminalPath:
			switch tp.selector {
			case UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorConditionalState:
				result.ConditionalState = source.ConditionalState
				wholeConditionalStateAccepted = true
			case UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			}
		case *UpdateProvisioningApprovalRequestRequestCAS_FieldSubPath:
			switch tp.selector {
			case UpdateProvisioningApprovalRequestRequestCAS_FieldPathSelectorConditionalState:
				conditionalStateMask.AppendPath(tp.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath))
			}
		}
	}
	if wholeConditionalStateAccepted == false && len(conditionalStateMask.Paths) > 0 {
		result.ConditionalState = conditionalStateMask.Project(source.GetConditionalState())
	}
	return result
}

func (fieldMask *UpdateProvisioningApprovalRequestRequest_CAS_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*UpdateProvisioningApprovalRequestRequest_CAS))
}

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

type DeleteProvisioningApprovalRequestRequest_FieldMask struct {
	Paths []DeleteProvisioningApprovalRequestRequest_FieldPath
}

func FullDeleteProvisioningApprovalRequestRequest_FieldMask() *DeleteProvisioningApprovalRequestRequest_FieldMask {
	res := &DeleteProvisioningApprovalRequestRequest_FieldMask{}
	res.Paths = append(res.Paths, &DeleteProvisioningApprovalRequestRequest_FieldTerminalPath{selector: DeleteProvisioningApprovalRequestRequest_FieldPathSelectorName})
	return res
}

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

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

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

func (fieldMask *DeleteProvisioningApprovalRequestRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *DeleteProvisioningApprovalRequestRequest_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 *DeleteProvisioningApprovalRequestRequest_FieldMask) AppendPath(path DeleteProvisioningApprovalRequestRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

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

func (fieldMask *DeleteProvisioningApprovalRequestRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*DeleteProvisioningApprovalRequestRequest))
}

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