role_binding_service.pb.fieldmask.go

// Code generated by protoc-gen-goten-object
// File: edgelq/iam/proto/v1alpha2/role_binding_service.proto
// DO NOT EDIT!!!

package role_binding_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 (
	organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization"
	project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	role_binding "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/role_binding"
	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 (
	_ = &organization.Organization{}
	_ = &project.Project{}
	_ = &role_binding.RoleBinding{}
	_ = &empty.Empty{}
	_ = &field_mask.FieldMask{}
	_ = &timestamp.Timestamp{}
	_ = view.View(0)
	_ = watch_type.WatchType(0)
)

type GetRoleBindingRequest_FieldMask struct {
	Paths []GetRoleBindingRequest_FieldPath
}

func FullGetRoleBindingRequest_FieldMask() *GetRoleBindingRequest_FieldMask {
	res := &GetRoleBindingRequest_FieldMask{}
	res.Paths = append(res.Paths, &GetRoleBindingRequest_FieldTerminalPath{selector: GetRoleBindingRequest_FieldPathSelectorName})
	res.Paths = append(res.Paths, &GetRoleBindingRequest_FieldTerminalPath{selector: GetRoleBindingRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &GetRoleBindingRequest_FieldTerminalPath{selector: GetRoleBindingRequest_FieldPathSelectorView})
	return res
}

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

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

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

func (fieldMask *GetRoleBindingRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *GetRoleBindingRequest_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 *GetRoleBindingRequest_FieldMask) AppendPath(path GetRoleBindingRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *GetRoleBindingRequest_FieldTerminalPath:
			switch tp.selector {
			case GetRoleBindingRequest_FieldPathSelectorName:
				result.Name = source.Name
			case GetRoleBindingRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case GetRoleBindingRequest_FieldPathSelectorView:
				result.View = source.View
			}
		}
	}
	return result
}

func (fieldMask *GetRoleBindingRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*GetRoleBindingRequest))
}

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

type BatchGetRoleBindingsRequest_FieldMask struct {
	Paths []BatchGetRoleBindingsRequest_FieldPath
}

func FullBatchGetRoleBindingsRequest_FieldMask() *BatchGetRoleBindingsRequest_FieldMask {
	res := &BatchGetRoleBindingsRequest_FieldMask{}
	res.Paths = append(res.Paths, &BatchGetRoleBindingsRequest_FieldTerminalPath{selector: BatchGetRoleBindingsRequest_FieldPathSelectorNames})
	res.Paths = append(res.Paths, &BatchGetRoleBindingsRequest_FieldTerminalPath{selector: BatchGetRoleBindingsRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &BatchGetRoleBindingsRequest_FieldTerminalPath{selector: BatchGetRoleBindingsRequest_FieldPathSelectorView})
	return res
}

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

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

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

func (fieldMask *BatchGetRoleBindingsRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *BatchGetRoleBindingsRequest_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 *BatchGetRoleBindingsRequest_FieldMask) AppendPath(path BatchGetRoleBindingsRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *BatchGetRoleBindingsRequest_FieldTerminalPath:
			switch tp.selector {
			case BatchGetRoleBindingsRequest_FieldPathSelectorNames:
				result.Names = source.Names
			case BatchGetRoleBindingsRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case BatchGetRoleBindingsRequest_FieldPathSelectorView:
				result.View = source.View
			}
		}
	}
	return result
}

func (fieldMask *BatchGetRoleBindingsRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*BatchGetRoleBindingsRequest))
}

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

type BatchGetRoleBindingsResponse_FieldMask struct {
	Paths []BatchGetRoleBindingsResponse_FieldPath
}

func FullBatchGetRoleBindingsResponse_FieldMask() *BatchGetRoleBindingsResponse_FieldMask {
	res := &BatchGetRoleBindingsResponse_FieldMask{}
	res.Paths = append(res.Paths, &BatchGetRoleBindingsResponse_FieldTerminalPath{selector: BatchGetRoleBindingsResponse_FieldPathSelectorRoleBindings})
	res.Paths = append(res.Paths, &BatchGetRoleBindingsResponse_FieldTerminalPath{selector: BatchGetRoleBindingsResponse_FieldPathSelectorMissing})
	return res
}

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

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

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

func (fieldMask *BatchGetRoleBindingsResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *BatchGetRoleBindingsResponse_FieldMask) Subtract(other *BatchGetRoleBindingsResponse_FieldMask) *BatchGetRoleBindingsResponse_FieldMask {
	result := &BatchGetRoleBindingsResponse_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[BatchGetRoleBindingsResponse_FieldPathSelector]gotenobject.FieldMask{
		BatchGetRoleBindingsResponse_FieldPathSelectorRoleBindings: &role_binding.RoleBinding_FieldMask{},
	}
	mySubMasks := map[BatchGetRoleBindingsResponse_FieldPathSelector]gotenobject.FieldMask{
		BatchGetRoleBindingsResponse_FieldPathSelectorRoleBindings: &role_binding.RoleBinding_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *BatchGetRoleBindingsResponse_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *BatchGetRoleBindingsResponse_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.(*BatchGetRoleBindingsResponse_FieldTerminalPath); ok {
					switch tp.selector {
					case BatchGetRoleBindingsResponse_FieldPathSelectorRoleBindings:
						mySubMasks[BatchGetRoleBindingsResponse_FieldPathSelectorRoleBindings] = role_binding.FullRoleBinding_FieldMask()
					}
				} else if tp, ok := path.(*BatchGetRoleBindingsResponse_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, &BatchGetRoleBindingsResponse_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *BatchGetRoleBindingsResponse_FieldMask) FilterInputFields() *BatchGetRoleBindingsResponse_FieldMask {
	result := &BatchGetRoleBindingsResponse_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case BatchGetRoleBindingsResponse_FieldPathSelectorRoleBindings:
			if _, ok := path.(*BatchGetRoleBindingsResponse_FieldTerminalPath); ok {
				for _, subpath := range role_binding.FullRoleBinding_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &BatchGetRoleBindingsResponse_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*BatchGetRoleBindingsResponse_FieldSubPath); ok {
				selectedMask := &role_binding.RoleBinding_FieldMask{
					Paths: []role_binding.RoleBinding_FieldPath{sub.subPath.(role_binding.RoleBinding_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &BatchGetRoleBindingsResponse_FieldSubPath{selector: BatchGetRoleBindingsResponse_FieldPathSelectorRoleBindings, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *BatchGetRoleBindingsResponse_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 *BatchGetRoleBindingsResponse_FieldMask) AppendPath(path BatchGetRoleBindingsResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *BatchGetRoleBindingsResponse_FieldMask) Project(source *BatchGetRoleBindingsResponse) *BatchGetRoleBindingsResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &BatchGetRoleBindingsResponse{}
	roleBindingsMask := &role_binding.RoleBinding_FieldMask{}
	wholeRoleBindingsAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *BatchGetRoleBindingsResponse_FieldTerminalPath:
			switch tp.selector {
			case BatchGetRoleBindingsResponse_FieldPathSelectorRoleBindings:
				result.RoleBindings = source.RoleBindings
				wholeRoleBindingsAccepted = true
			case BatchGetRoleBindingsResponse_FieldPathSelectorMissing:
				result.Missing = source.Missing
			}
		case *BatchGetRoleBindingsResponse_FieldSubPath:
			switch tp.selector {
			case BatchGetRoleBindingsResponse_FieldPathSelectorRoleBindings:
				roleBindingsMask.AppendPath(tp.subPath.(role_binding.RoleBinding_FieldPath))
			}
		}
	}
	if wholeRoleBindingsAccepted == false && len(roleBindingsMask.Paths) > 0 {
		for _, sourceItem := range source.GetRoleBindings() {
			result.RoleBindings = append(result.RoleBindings, roleBindingsMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *BatchGetRoleBindingsResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*BatchGetRoleBindingsResponse))
}

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

type ListRoleBindingsRequest_FieldMask struct {
	Paths []ListRoleBindingsRequest_FieldPath
}

func FullListRoleBindingsRequest_FieldMask() *ListRoleBindingsRequest_FieldMask {
	res := &ListRoleBindingsRequest_FieldMask{}
	res.Paths = append(res.Paths, &ListRoleBindingsRequest_FieldTerminalPath{selector: ListRoleBindingsRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &ListRoleBindingsRequest_FieldTerminalPath{selector: ListRoleBindingsRequest_FieldPathSelectorPageSize})
	res.Paths = append(res.Paths, &ListRoleBindingsRequest_FieldTerminalPath{selector: ListRoleBindingsRequest_FieldPathSelectorPageToken})
	res.Paths = append(res.Paths, &ListRoleBindingsRequest_FieldTerminalPath{selector: ListRoleBindingsRequest_FieldPathSelectorOrderBy})
	res.Paths = append(res.Paths, &ListRoleBindingsRequest_FieldTerminalPath{selector: ListRoleBindingsRequest_FieldPathSelectorFilter})
	res.Paths = append(res.Paths, &ListRoleBindingsRequest_FieldTerminalPath{selector: ListRoleBindingsRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &ListRoleBindingsRequest_FieldTerminalPath{selector: ListRoleBindingsRequest_FieldPathSelectorView})
	res.Paths = append(res.Paths, &ListRoleBindingsRequest_FieldTerminalPath{selector: ListRoleBindingsRequest_FieldPathSelectorIncludePagingInfo})
	return res
}

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

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

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

func (fieldMask *ListRoleBindingsRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *ListRoleBindingsRequest_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 *ListRoleBindingsRequest_FieldMask) AppendPath(path ListRoleBindingsRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *ListRoleBindingsRequest_FieldTerminalPath:
			switch tp.selector {
			case ListRoleBindingsRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case ListRoleBindingsRequest_FieldPathSelectorPageSize:
				result.PageSize = source.PageSize
			case ListRoleBindingsRequest_FieldPathSelectorPageToken:
				result.PageToken = source.PageToken
			case ListRoleBindingsRequest_FieldPathSelectorOrderBy:
				result.OrderBy = source.OrderBy
			case ListRoleBindingsRequest_FieldPathSelectorFilter:
				result.Filter = source.Filter
			case ListRoleBindingsRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case ListRoleBindingsRequest_FieldPathSelectorView:
				result.View = source.View
			case ListRoleBindingsRequest_FieldPathSelectorIncludePagingInfo:
				result.IncludePagingInfo = source.IncludePagingInfo
			}
		}
	}
	return result
}

func (fieldMask *ListRoleBindingsRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*ListRoleBindingsRequest))
}

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

type ListRoleBindingsResponse_FieldMask struct {
	Paths []ListRoleBindingsResponse_FieldPath
}

func FullListRoleBindingsResponse_FieldMask() *ListRoleBindingsResponse_FieldMask {
	res := &ListRoleBindingsResponse_FieldMask{}
	res.Paths = append(res.Paths, &ListRoleBindingsResponse_FieldTerminalPath{selector: ListRoleBindingsResponse_FieldPathSelectorRoleBindings})
	res.Paths = append(res.Paths, &ListRoleBindingsResponse_FieldTerminalPath{selector: ListRoleBindingsResponse_FieldPathSelectorPrevPageToken})
	res.Paths = append(res.Paths, &ListRoleBindingsResponse_FieldTerminalPath{selector: ListRoleBindingsResponse_FieldPathSelectorNextPageToken})
	res.Paths = append(res.Paths, &ListRoleBindingsResponse_FieldTerminalPath{selector: ListRoleBindingsResponse_FieldPathSelectorCurrentOffset})
	res.Paths = append(res.Paths, &ListRoleBindingsResponse_FieldTerminalPath{selector: ListRoleBindingsResponse_FieldPathSelectorTotalResultsCount})
	return res
}

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

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

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

func (fieldMask *ListRoleBindingsResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *ListRoleBindingsResponse_FieldMask) Subtract(other *ListRoleBindingsResponse_FieldMask) *ListRoleBindingsResponse_FieldMask {
	result := &ListRoleBindingsResponse_FieldMask{}
	removedSelectors := make([]bool, 5)
	otherSubMasks := map[ListRoleBindingsResponse_FieldPathSelector]gotenobject.FieldMask{
		ListRoleBindingsResponse_FieldPathSelectorRoleBindings: &role_binding.RoleBinding_FieldMask{},
	}
	mySubMasks := map[ListRoleBindingsResponse_FieldPathSelector]gotenobject.FieldMask{
		ListRoleBindingsResponse_FieldPathSelectorRoleBindings: &role_binding.RoleBinding_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *ListRoleBindingsResponse_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *ListRoleBindingsResponse_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.(*ListRoleBindingsResponse_FieldTerminalPath); ok {
					switch tp.selector {
					case ListRoleBindingsResponse_FieldPathSelectorRoleBindings:
						mySubMasks[ListRoleBindingsResponse_FieldPathSelectorRoleBindings] = role_binding.FullRoleBinding_FieldMask()
					}
				} else if tp, ok := path.(*ListRoleBindingsResponse_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, &ListRoleBindingsResponse_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *ListRoleBindingsResponse_FieldMask) FilterInputFields() *ListRoleBindingsResponse_FieldMask {
	result := &ListRoleBindingsResponse_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case ListRoleBindingsResponse_FieldPathSelectorRoleBindings:
			if _, ok := path.(*ListRoleBindingsResponse_FieldTerminalPath); ok {
				for _, subpath := range role_binding.FullRoleBinding_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &ListRoleBindingsResponse_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*ListRoleBindingsResponse_FieldSubPath); ok {
				selectedMask := &role_binding.RoleBinding_FieldMask{
					Paths: []role_binding.RoleBinding_FieldPath{sub.subPath.(role_binding.RoleBinding_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &ListRoleBindingsResponse_FieldSubPath{selector: ListRoleBindingsResponse_FieldPathSelectorRoleBindings, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *ListRoleBindingsResponse_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 *ListRoleBindingsResponse_FieldMask) AppendPath(path ListRoleBindingsResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *ListRoleBindingsResponse_FieldMask) Project(source *ListRoleBindingsResponse) *ListRoleBindingsResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &ListRoleBindingsResponse{}
	roleBindingsMask := &role_binding.RoleBinding_FieldMask{}
	wholeRoleBindingsAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *ListRoleBindingsResponse_FieldTerminalPath:
			switch tp.selector {
			case ListRoleBindingsResponse_FieldPathSelectorRoleBindings:
				result.RoleBindings = source.RoleBindings
				wholeRoleBindingsAccepted = true
			case ListRoleBindingsResponse_FieldPathSelectorPrevPageToken:
				result.PrevPageToken = source.PrevPageToken
			case ListRoleBindingsResponse_FieldPathSelectorNextPageToken:
				result.NextPageToken = source.NextPageToken
			case ListRoleBindingsResponse_FieldPathSelectorCurrentOffset:
				result.CurrentOffset = source.CurrentOffset
			case ListRoleBindingsResponse_FieldPathSelectorTotalResultsCount:
				result.TotalResultsCount = source.TotalResultsCount
			}
		case *ListRoleBindingsResponse_FieldSubPath:
			switch tp.selector {
			case ListRoleBindingsResponse_FieldPathSelectorRoleBindings:
				roleBindingsMask.AppendPath(tp.subPath.(role_binding.RoleBinding_FieldPath))
			}
		}
	}
	if wholeRoleBindingsAccepted == false && len(roleBindingsMask.Paths) > 0 {
		for _, sourceItem := range source.GetRoleBindings() {
			result.RoleBindings = append(result.RoleBindings, roleBindingsMask.Project(sourceItem))
		}
	}
	return result
}

func (fieldMask *ListRoleBindingsResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*ListRoleBindingsResponse))
}

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

type WatchRoleBindingRequest_FieldMask struct {
	Paths []WatchRoleBindingRequest_FieldPath
}

func FullWatchRoleBindingRequest_FieldMask() *WatchRoleBindingRequest_FieldMask {
	res := &WatchRoleBindingRequest_FieldMask{}
	res.Paths = append(res.Paths, &WatchRoleBindingRequest_FieldTerminalPath{selector: WatchRoleBindingRequest_FieldPathSelectorName})
	res.Paths = append(res.Paths, &WatchRoleBindingRequest_FieldTerminalPath{selector: WatchRoleBindingRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &WatchRoleBindingRequest_FieldTerminalPath{selector: WatchRoleBindingRequest_FieldPathSelectorView})
	return res
}

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

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

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

func (fieldMask *WatchRoleBindingRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchRoleBindingRequest_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 *WatchRoleBindingRequest_FieldMask) AppendPath(path WatchRoleBindingRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchRoleBindingRequest_FieldTerminalPath:
			switch tp.selector {
			case WatchRoleBindingRequest_FieldPathSelectorName:
				result.Name = source.Name
			case WatchRoleBindingRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case WatchRoleBindingRequest_FieldPathSelectorView:
				result.View = source.View
			}
		}
	}
	return result
}

func (fieldMask *WatchRoleBindingRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchRoleBindingRequest))
}

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

type WatchRoleBindingResponse_FieldMask struct {
	Paths []WatchRoleBindingResponse_FieldPath
}

func FullWatchRoleBindingResponse_FieldMask() *WatchRoleBindingResponse_FieldMask {
	res := &WatchRoleBindingResponse_FieldMask{}
	res.Paths = append(res.Paths, &WatchRoleBindingResponse_FieldTerminalPath{selector: WatchRoleBindingResponse_FieldPathSelectorChange})
	return res
}

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

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

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

func (fieldMask *WatchRoleBindingResponse_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchRoleBindingResponse_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 *WatchRoleBindingResponse_FieldMask) AppendPath(path WatchRoleBindingResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

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

func (fieldMask *WatchRoleBindingResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchRoleBindingResponse))
}

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

type WatchRoleBindingsRequest_FieldMask struct {
	Paths []WatchRoleBindingsRequest_FieldPath
}

func FullWatchRoleBindingsRequest_FieldMask() *WatchRoleBindingsRequest_FieldMask {
	res := &WatchRoleBindingsRequest_FieldMask{}
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorType})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorPageSize})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorPageToken})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorOrderBy})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorResumeToken})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorStartingTime})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorFilter})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorFieldMask})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorView})
	res.Paths = append(res.Paths, &WatchRoleBindingsRequest_FieldTerminalPath{selector: WatchRoleBindingsRequest_FieldPathSelectorMaxChunkSize})
	return res
}

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

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

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

func (fieldMask *WatchRoleBindingsRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchRoleBindingsRequest_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 *WatchRoleBindingsRequest_FieldMask) AppendPath(path WatchRoleBindingsRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchRoleBindingsRequest_FieldTerminalPath:
			switch tp.selector {
			case WatchRoleBindingsRequest_FieldPathSelectorType:
				result.Type = source.Type
			case WatchRoleBindingsRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case WatchRoleBindingsRequest_FieldPathSelectorPageSize:
				result.PageSize = source.PageSize
			case WatchRoleBindingsRequest_FieldPathSelectorPageToken:
				result.PageToken = source.PageToken
			case WatchRoleBindingsRequest_FieldPathSelectorOrderBy:
				result.OrderBy = source.OrderBy
			case WatchRoleBindingsRequest_FieldPathSelectorResumeToken:
				result.ResumeToken = source.ResumeToken
			case WatchRoleBindingsRequest_FieldPathSelectorStartingTime:
				result.StartingTime = source.StartingTime
			case WatchRoleBindingsRequest_FieldPathSelectorFilter:
				result.Filter = source.Filter
			case WatchRoleBindingsRequest_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			case WatchRoleBindingsRequest_FieldPathSelectorView:
				result.View = source.View
			case WatchRoleBindingsRequest_FieldPathSelectorMaxChunkSize:
				result.MaxChunkSize = source.MaxChunkSize
			}
		}
	}
	return result
}

func (fieldMask *WatchRoleBindingsRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchRoleBindingsRequest))
}

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

type WatchRoleBindingsResponse_FieldMask struct {
	Paths []WatchRoleBindingsResponse_FieldPath
}

func FullWatchRoleBindingsResponse_FieldMask() *WatchRoleBindingsResponse_FieldMask {
	res := &WatchRoleBindingsResponse_FieldMask{}
	res.Paths = append(res.Paths, &WatchRoleBindingsResponse_FieldTerminalPath{selector: WatchRoleBindingsResponse_FieldPathSelectorRoleBindingChanges})
	res.Paths = append(res.Paths, &WatchRoleBindingsResponse_FieldTerminalPath{selector: WatchRoleBindingsResponse_FieldPathSelectorIsCurrent})
	res.Paths = append(res.Paths, &WatchRoleBindingsResponse_FieldTerminalPath{selector: WatchRoleBindingsResponse_FieldPathSelectorPageTokenChange})
	res.Paths = append(res.Paths, &WatchRoleBindingsResponse_FieldTerminalPath{selector: WatchRoleBindingsResponse_FieldPathSelectorResumeToken})
	res.Paths = append(res.Paths, &WatchRoleBindingsResponse_FieldTerminalPath{selector: WatchRoleBindingsResponse_FieldPathSelectorSnapshotSize})
	res.Paths = append(res.Paths, &WatchRoleBindingsResponse_FieldTerminalPath{selector: WatchRoleBindingsResponse_FieldPathSelectorIsSoftReset})
	res.Paths = append(res.Paths, &WatchRoleBindingsResponse_FieldTerminalPath{selector: WatchRoleBindingsResponse_FieldPathSelectorIsHardReset})
	return res
}

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

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

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

func (fieldMask *WatchRoleBindingsResponse_FieldMask) ProtoMessage() {}

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

func (fieldMask *WatchRoleBindingsResponse_FieldMask) Subtract(other *WatchRoleBindingsResponse_FieldMask) *WatchRoleBindingsResponse_FieldMask {
	result := &WatchRoleBindingsResponse_FieldMask{}
	removedSelectors := make([]bool, 7)
	otherSubMasks := map[WatchRoleBindingsResponse_FieldPathSelector]gotenobject.FieldMask{
		WatchRoleBindingsResponse_FieldPathSelectorPageTokenChange: &WatchRoleBindingsResponse_PageTokenChange_FieldMask{},
	}
	mySubMasks := map[WatchRoleBindingsResponse_FieldPathSelector]gotenobject.FieldMask{
		WatchRoleBindingsResponse_FieldPathSelectorPageTokenChange: &WatchRoleBindingsResponse_PageTokenChange_FieldMask{},
	}

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchRoleBindingsResponse_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 *WatchRoleBindingsResponse_FieldMask) AppendPath(path WatchRoleBindingsResponse_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *WatchRoleBindingsResponse_FieldMask) Project(source *WatchRoleBindingsResponse) *WatchRoleBindingsResponse {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &WatchRoleBindingsResponse{}
	pageTokenChangeMask := &WatchRoleBindingsResponse_PageTokenChange_FieldMask{}
	wholePageTokenChangeAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *WatchRoleBindingsResponse_FieldTerminalPath:
			switch tp.selector {
			case WatchRoleBindingsResponse_FieldPathSelectorRoleBindingChanges:
				result.RoleBindingChanges = source.RoleBindingChanges
			case WatchRoleBindingsResponse_FieldPathSelectorIsCurrent:
				result.IsCurrent = source.IsCurrent
			case WatchRoleBindingsResponse_FieldPathSelectorPageTokenChange:
				result.PageTokenChange = source.PageTokenChange
				wholePageTokenChangeAccepted = true
			case WatchRoleBindingsResponse_FieldPathSelectorResumeToken:
				result.ResumeToken = source.ResumeToken
			case WatchRoleBindingsResponse_FieldPathSelectorSnapshotSize:
				result.SnapshotSize = source.SnapshotSize
			case WatchRoleBindingsResponse_FieldPathSelectorIsSoftReset:
				result.IsSoftReset = source.IsSoftReset
			case WatchRoleBindingsResponse_FieldPathSelectorIsHardReset:
				result.IsHardReset = source.IsHardReset
			}
		case *WatchRoleBindingsResponse_FieldSubPath:
			switch tp.selector {
			case WatchRoleBindingsResponse_FieldPathSelectorPageTokenChange:
				pageTokenChangeMask.AppendPath(tp.subPath.(WatchRoleBindingsResponsePageTokenChange_FieldPath))
			}
		}
	}
	if wholePageTokenChangeAccepted == false && len(pageTokenChangeMask.Paths) > 0 {
		result.PageTokenChange = pageTokenChangeMask.Project(source.GetPageTokenChange())
	}
	return result
}

func (fieldMask *WatchRoleBindingsResponse_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchRoleBindingsResponse))
}

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

type WatchRoleBindingsResponse_PageTokenChange_FieldMask struct {
	Paths []WatchRoleBindingsResponsePageTokenChange_FieldPath
}

func FullWatchRoleBindingsResponse_PageTokenChange_FieldMask() *WatchRoleBindingsResponse_PageTokenChange_FieldMask {
	res := &WatchRoleBindingsResponse_PageTokenChange_FieldMask{}
	res.Paths = append(res.Paths, &WatchRoleBindingsResponsePageTokenChange_FieldTerminalPath{selector: WatchRoleBindingsResponsePageTokenChange_FieldPathSelectorPrevPageToken})
	res.Paths = append(res.Paths, &WatchRoleBindingsResponsePageTokenChange_FieldTerminalPath{selector: WatchRoleBindingsResponsePageTokenChange_FieldPathSelectorNextPageToken})
	return res
}

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

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

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

func (fieldMask *WatchRoleBindingsResponse_PageTokenChange_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *WatchRoleBindingsResponse_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 *WatchRoleBindingsResponse_PageTokenChange_FieldMask) AppendPath(path WatchRoleBindingsResponsePageTokenChange_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

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

func (fieldMask *WatchRoleBindingsResponse_PageTokenChange_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*WatchRoleBindingsResponse_PageTokenChange))
}

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

type CreateRoleBindingRequest_FieldMask struct {
	Paths []CreateRoleBindingRequest_FieldPath
}

func FullCreateRoleBindingRequest_FieldMask() *CreateRoleBindingRequest_FieldMask {
	res := &CreateRoleBindingRequest_FieldMask{}
	res.Paths = append(res.Paths, &CreateRoleBindingRequest_FieldTerminalPath{selector: CreateRoleBindingRequest_FieldPathSelectorParent})
	res.Paths = append(res.Paths, &CreateRoleBindingRequest_FieldTerminalPath{selector: CreateRoleBindingRequest_FieldPathSelectorRoleBinding})
	return res
}

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

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

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

func (fieldMask *CreateRoleBindingRequest_FieldMask) ProtoMessage() {}

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

func (fieldMask *CreateRoleBindingRequest_FieldMask) Subtract(other *CreateRoleBindingRequest_FieldMask) *CreateRoleBindingRequest_FieldMask {
	result := &CreateRoleBindingRequest_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[CreateRoleBindingRequest_FieldPathSelector]gotenobject.FieldMask{
		CreateRoleBindingRequest_FieldPathSelectorRoleBinding: &role_binding.RoleBinding_FieldMask{},
	}
	mySubMasks := map[CreateRoleBindingRequest_FieldPathSelector]gotenobject.FieldMask{
		CreateRoleBindingRequest_FieldPathSelectorRoleBinding: &role_binding.RoleBinding_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *CreateRoleBindingRequest_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *CreateRoleBindingRequest_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.(*CreateRoleBindingRequest_FieldTerminalPath); ok {
					switch tp.selector {
					case CreateRoleBindingRequest_FieldPathSelectorRoleBinding:
						mySubMasks[CreateRoleBindingRequest_FieldPathSelectorRoleBinding] = role_binding.FullRoleBinding_FieldMask()
					}
				} else if tp, ok := path.(*CreateRoleBindingRequest_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, &CreateRoleBindingRequest_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *CreateRoleBindingRequest_FieldMask) FilterInputFields() *CreateRoleBindingRequest_FieldMask {
	result := &CreateRoleBindingRequest_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case CreateRoleBindingRequest_FieldPathSelectorRoleBinding:
			if _, ok := path.(*CreateRoleBindingRequest_FieldTerminalPath); ok {
				for _, subpath := range role_binding.FullRoleBinding_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &CreateRoleBindingRequest_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*CreateRoleBindingRequest_FieldSubPath); ok {
				selectedMask := &role_binding.RoleBinding_FieldMask{
					Paths: []role_binding.RoleBinding_FieldPath{sub.subPath.(role_binding.RoleBinding_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &CreateRoleBindingRequest_FieldSubPath{selector: CreateRoleBindingRequest_FieldPathSelectorRoleBinding, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *CreateRoleBindingRequest_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 *CreateRoleBindingRequest_FieldMask) AppendPath(path CreateRoleBindingRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *CreateRoleBindingRequest_FieldMask) Project(source *CreateRoleBindingRequest) *CreateRoleBindingRequest {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &CreateRoleBindingRequest{}
	roleBindingMask := &role_binding.RoleBinding_FieldMask{}
	wholeRoleBindingAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *CreateRoleBindingRequest_FieldTerminalPath:
			switch tp.selector {
			case CreateRoleBindingRequest_FieldPathSelectorParent:
				result.Parent = source.Parent
			case CreateRoleBindingRequest_FieldPathSelectorRoleBinding:
				result.RoleBinding = source.RoleBinding
				wholeRoleBindingAccepted = true
			}
		case *CreateRoleBindingRequest_FieldSubPath:
			switch tp.selector {
			case CreateRoleBindingRequest_FieldPathSelectorRoleBinding:
				roleBindingMask.AppendPath(tp.subPath.(role_binding.RoleBinding_FieldPath))
			}
		}
	}
	if wholeRoleBindingAccepted == false && len(roleBindingMask.Paths) > 0 {
		result.RoleBinding = roleBindingMask.Project(source.GetRoleBinding())
	}
	return result
}

func (fieldMask *CreateRoleBindingRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*CreateRoleBindingRequest))
}

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

type UpdateRoleBindingRequest_FieldMask struct {
	Paths []UpdateRoleBindingRequest_FieldPath
}

func FullUpdateRoleBindingRequest_FieldMask() *UpdateRoleBindingRequest_FieldMask {
	res := &UpdateRoleBindingRequest_FieldMask{}
	res.Paths = append(res.Paths, &UpdateRoleBindingRequest_FieldTerminalPath{selector: UpdateRoleBindingRequest_FieldPathSelectorRoleBinding})
	res.Paths = append(res.Paths, &UpdateRoleBindingRequest_FieldTerminalPath{selector: UpdateRoleBindingRequest_FieldPathSelectorUpdateMask})
	res.Paths = append(res.Paths, &UpdateRoleBindingRequest_FieldTerminalPath{selector: UpdateRoleBindingRequest_FieldPathSelectorCas})
	return res
}

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

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

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

func (fieldMask *UpdateRoleBindingRequest_FieldMask) ProtoMessage() {}

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

func (fieldMask *UpdateRoleBindingRequest_FieldMask) Subtract(other *UpdateRoleBindingRequest_FieldMask) *UpdateRoleBindingRequest_FieldMask {
	result := &UpdateRoleBindingRequest_FieldMask{}
	removedSelectors := make([]bool, 3)
	otherSubMasks := map[UpdateRoleBindingRequest_FieldPathSelector]gotenobject.FieldMask{
		UpdateRoleBindingRequest_FieldPathSelectorRoleBinding: &role_binding.RoleBinding_FieldMask{},
		UpdateRoleBindingRequest_FieldPathSelectorCas:         &UpdateRoleBindingRequest_CAS_FieldMask{},
	}
	mySubMasks := map[UpdateRoleBindingRequest_FieldPathSelector]gotenobject.FieldMask{
		UpdateRoleBindingRequest_FieldPathSelectorRoleBinding: &role_binding.RoleBinding_FieldMask{},
		UpdateRoleBindingRequest_FieldPathSelectorCas:         &UpdateRoleBindingRequest_CAS_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *UpdateRoleBindingRequest_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *UpdateRoleBindingRequest_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.(*UpdateRoleBindingRequest_FieldTerminalPath); ok {
					switch tp.selector {
					case UpdateRoleBindingRequest_FieldPathSelectorRoleBinding:
						mySubMasks[UpdateRoleBindingRequest_FieldPathSelectorRoleBinding] = role_binding.FullRoleBinding_FieldMask()
					case UpdateRoleBindingRequest_FieldPathSelectorCas:
						mySubMasks[UpdateRoleBindingRequest_FieldPathSelectorCas] = FullUpdateRoleBindingRequest_CAS_FieldMask()
					}
				} else if tp, ok := path.(*UpdateRoleBindingRequest_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, &UpdateRoleBindingRequest_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *UpdateRoleBindingRequest_FieldMask) FilterInputFields() *UpdateRoleBindingRequest_FieldMask {
	result := &UpdateRoleBindingRequest_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case UpdateRoleBindingRequest_FieldPathSelectorRoleBinding:
			if _, ok := path.(*UpdateRoleBindingRequest_FieldTerminalPath); ok {
				for _, subpath := range role_binding.FullRoleBinding_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateRoleBindingRequest_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*UpdateRoleBindingRequest_FieldSubPath); ok {
				selectedMask := &role_binding.RoleBinding_FieldMask{
					Paths: []role_binding.RoleBinding_FieldPath{sub.subPath.(role_binding.RoleBinding_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateRoleBindingRequest_FieldSubPath{selector: UpdateRoleBindingRequest_FieldPathSelectorRoleBinding, subPath: allowedPath})
				}
			}
		case UpdateRoleBindingRequest_FieldPathSelectorCas:
			if _, ok := path.(*UpdateRoleBindingRequest_FieldTerminalPath); ok {
				for _, subpath := range FullUpdateRoleBindingRequest_CAS_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateRoleBindingRequest_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*UpdateRoleBindingRequest_FieldSubPath); ok {
				selectedMask := &UpdateRoleBindingRequest_CAS_FieldMask{
					Paths: []UpdateRoleBindingRequestCAS_FieldPath{sub.subPath.(UpdateRoleBindingRequestCAS_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateRoleBindingRequest_FieldSubPath{selector: UpdateRoleBindingRequest_FieldPathSelectorCas, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *UpdateRoleBindingRequest_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 *UpdateRoleBindingRequest_FieldMask) AppendPath(path UpdateRoleBindingRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *UpdateRoleBindingRequest_FieldMask) Project(source *UpdateRoleBindingRequest) *UpdateRoleBindingRequest {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &UpdateRoleBindingRequest{}
	roleBindingMask := &role_binding.RoleBinding_FieldMask{}
	wholeRoleBindingAccepted := false
	casMask := &UpdateRoleBindingRequest_CAS_FieldMask{}
	wholeCasAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *UpdateRoleBindingRequest_FieldTerminalPath:
			switch tp.selector {
			case UpdateRoleBindingRequest_FieldPathSelectorRoleBinding:
				result.RoleBinding = source.RoleBinding
				wholeRoleBindingAccepted = true
			case UpdateRoleBindingRequest_FieldPathSelectorUpdateMask:
				result.UpdateMask = source.UpdateMask
			case UpdateRoleBindingRequest_FieldPathSelectorCas:
				result.Cas = source.Cas
				wholeCasAccepted = true
			}
		case *UpdateRoleBindingRequest_FieldSubPath:
			switch tp.selector {
			case UpdateRoleBindingRequest_FieldPathSelectorRoleBinding:
				roleBindingMask.AppendPath(tp.subPath.(role_binding.RoleBinding_FieldPath))
			case UpdateRoleBindingRequest_FieldPathSelectorCas:
				casMask.AppendPath(tp.subPath.(UpdateRoleBindingRequestCAS_FieldPath))
			}
		}
	}
	if wholeRoleBindingAccepted == false && len(roleBindingMask.Paths) > 0 {
		result.RoleBinding = roleBindingMask.Project(source.GetRoleBinding())
	}
	if wholeCasAccepted == false && len(casMask.Paths) > 0 {
		result.Cas = casMask.Project(source.GetCas())
	}
	return result
}

func (fieldMask *UpdateRoleBindingRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*UpdateRoleBindingRequest))
}

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

type UpdateRoleBindingRequest_CAS_FieldMask struct {
	Paths []UpdateRoleBindingRequestCAS_FieldPath
}

func FullUpdateRoleBindingRequest_CAS_FieldMask() *UpdateRoleBindingRequest_CAS_FieldMask {
	res := &UpdateRoleBindingRequest_CAS_FieldMask{}
	res.Paths = append(res.Paths, &UpdateRoleBindingRequestCAS_FieldTerminalPath{selector: UpdateRoleBindingRequestCAS_FieldPathSelectorConditionalState})
	res.Paths = append(res.Paths, &UpdateRoleBindingRequestCAS_FieldTerminalPath{selector: UpdateRoleBindingRequestCAS_FieldPathSelectorFieldMask})
	return res
}

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

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

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

func (fieldMask *UpdateRoleBindingRequest_CAS_FieldMask) ProtoMessage() {}

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

func (fieldMask *UpdateRoleBindingRequest_CAS_FieldMask) Subtract(other *UpdateRoleBindingRequest_CAS_FieldMask) *UpdateRoleBindingRequest_CAS_FieldMask {
	result := &UpdateRoleBindingRequest_CAS_FieldMask{}
	removedSelectors := make([]bool, 2)
	otherSubMasks := map[UpdateRoleBindingRequestCAS_FieldPathSelector]gotenobject.FieldMask{
		UpdateRoleBindingRequestCAS_FieldPathSelectorConditionalState: &role_binding.RoleBinding_FieldMask{},
	}
	mySubMasks := map[UpdateRoleBindingRequestCAS_FieldPathSelector]gotenobject.FieldMask{
		UpdateRoleBindingRequestCAS_FieldPathSelectorConditionalState: &role_binding.RoleBinding_FieldMask{},
	}

	for _, path := range other.GetPaths() {
		switch tp := path.(type) {
		case *UpdateRoleBindingRequestCAS_FieldTerminalPath:
			removedSelectors[int(tp.selector)] = true
		case *UpdateRoleBindingRequestCAS_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.(*UpdateRoleBindingRequestCAS_FieldTerminalPath); ok {
					switch tp.selector {
					case UpdateRoleBindingRequestCAS_FieldPathSelectorConditionalState:
						mySubMasks[UpdateRoleBindingRequestCAS_FieldPathSelectorConditionalState] = role_binding.FullRoleBinding_FieldMask()
					}
				} else if tp, ok := path.(*UpdateRoleBindingRequestCAS_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, &UpdateRoleBindingRequestCAS_FieldSubPath{selector: selector, subPath: allowedPath})
			}
		}
	}

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

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

// FilterInputFields generates copy of field paths with output_only field paths removed
func (fieldMask *UpdateRoleBindingRequest_CAS_FieldMask) FilterInputFields() *UpdateRoleBindingRequest_CAS_FieldMask {
	result := &UpdateRoleBindingRequest_CAS_FieldMask{}
	for _, path := range fieldMask.Paths {
		switch path.Selector() {
		case UpdateRoleBindingRequestCAS_FieldPathSelectorConditionalState:
			if _, ok := path.(*UpdateRoleBindingRequestCAS_FieldTerminalPath); ok {
				for _, subpath := range role_binding.FullRoleBinding_FieldMask().FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateRoleBindingRequestCAS_FieldSubPath{selector: path.Selector(), subPath: subpath})
				}
			} else if sub, ok := path.(*UpdateRoleBindingRequestCAS_FieldSubPath); ok {
				selectedMask := &role_binding.RoleBinding_FieldMask{
					Paths: []role_binding.RoleBinding_FieldPath{sub.subPath.(role_binding.RoleBinding_FieldPath)},
				}
				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
					result.Paths = append(result.Paths, &UpdateRoleBindingRequestCAS_FieldSubPath{selector: UpdateRoleBindingRequestCAS_FieldPathSelectorConditionalState, subPath: allowedPath})
				}
			}
		default:
			result.Paths = append(result.Paths, path)
		}
	}
	return result
}

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

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

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

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

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

func (fieldMask *UpdateRoleBindingRequest_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 *UpdateRoleBindingRequest_CAS_FieldMask) AppendPath(path UpdateRoleBindingRequestCAS_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

func (fieldMask *UpdateRoleBindingRequest_CAS_FieldMask) Project(source *UpdateRoleBindingRequest_CAS) *UpdateRoleBindingRequest_CAS {
	if source == nil {
		return nil
	}
	if fieldMask == nil {
		return source
	}
	result := &UpdateRoleBindingRequest_CAS{}
	conditionalStateMask := &role_binding.RoleBinding_FieldMask{}
	wholeConditionalStateAccepted := false

	for _, p := range fieldMask.Paths {
		switch tp := p.(type) {
		case *UpdateRoleBindingRequestCAS_FieldTerminalPath:
			switch tp.selector {
			case UpdateRoleBindingRequestCAS_FieldPathSelectorConditionalState:
				result.ConditionalState = source.ConditionalState
				wholeConditionalStateAccepted = true
			case UpdateRoleBindingRequestCAS_FieldPathSelectorFieldMask:
				result.FieldMask = source.FieldMask
			}
		case *UpdateRoleBindingRequestCAS_FieldSubPath:
			switch tp.selector {
			case UpdateRoleBindingRequestCAS_FieldPathSelectorConditionalState:
				conditionalStateMask.AppendPath(tp.subPath.(role_binding.RoleBinding_FieldPath))
			}
		}
	}
	if wholeConditionalStateAccepted == false && len(conditionalStateMask.Paths) > 0 {
		result.ConditionalState = conditionalStateMask.Project(source.GetConditionalState())
	}
	return result
}

func (fieldMask *UpdateRoleBindingRequest_CAS_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*UpdateRoleBindingRequest_CAS))
}

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

type DeleteRoleBindingRequest_FieldMask struct {
	Paths []DeleteRoleBindingRequest_FieldPath
}

func FullDeleteRoleBindingRequest_FieldMask() *DeleteRoleBindingRequest_FieldMask {
	res := &DeleteRoleBindingRequest_FieldMask{}
	res.Paths = append(res.Paths, &DeleteRoleBindingRequest_FieldTerminalPath{selector: DeleteRoleBindingRequest_FieldPathSelectorName})
	return res
}

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

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

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

func (fieldMask *DeleteRoleBindingRequest_FieldMask) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

func (fieldMask *DeleteRoleBindingRequest_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 *DeleteRoleBindingRequest_FieldMask) AppendPath(path DeleteRoleBindingRequest_FieldPath) {
	fieldMask.Paths = append(fieldMask.Paths, path)
}

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

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

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

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

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

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

func (fieldMask *DeleteRoleBindingRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
	return fieldMask.Project(source.(*DeleteRoleBindingRequest))
}

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