project_service.pb.fieldpath.go

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

package project_client

import (
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
	"time"

	"github.com/iancoleman/strcase"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/encoding/protojson"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/reflect/protoregistry"
	"google.golang.org/protobuf/types/known/fieldmaskpb"

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

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

// ensure the imports are used
var (
	_ = json.Marshaler(nil)
	_ = fmt.Stringer(nil)
	_ = reflect.DeepEqual
	_ = strings.Builder{}
	_ = time.Second

	_ = strcase.ToLowerCamel
	_ = codes.NotFound
	_ = status.Status{}
	_ = protojson.UnmarshalOptions{}
	_ = proto.Message(nil)
	_ = protoregistry.GlobalTypes
	_ = fieldmaskpb.FieldMask{}

	_ = gotenobject.FieldPath(nil)
)

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

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type GetProjectRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() GetProjectRequest_FieldPathSelector
	Get(source *GetProjectRequest) []interface{}
	GetSingle(source *GetProjectRequest) (interface{}, bool)
	ClearValue(item *GetProjectRequest)

	// Those methods build corresponding GetProjectRequest_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) GetProjectRequest_FieldPathValue
	WithIArrayOfValues(values interface{}) GetProjectRequest_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) GetProjectRequest_FieldPathArrayItemValue
}

type GetProjectRequest_FieldPathSelector int32

const (
	GetProjectRequest_FieldPathSelectorName      GetProjectRequest_FieldPathSelector = 0
	GetProjectRequest_FieldPathSelectorFieldMask GetProjectRequest_FieldPathSelector = 1
	GetProjectRequest_FieldPathSelectorView      GetProjectRequest_FieldPathSelector = 2
)

func (s GetProjectRequest_FieldPathSelector) String() string {
	switch s {
	case GetProjectRequest_FieldPathSelectorName:
		return "name"
	case GetProjectRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case GetProjectRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", s))
	}
}

func BuildGetProjectRequest_FieldPath(fp gotenobject.RawFieldPath) (GetProjectRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object GetProjectRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &GetProjectRequest_FieldTerminalPath{selector: GetProjectRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &GetProjectRequest_FieldTerminalPath{selector: GetProjectRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &GetProjectRequest_FieldTerminalPath{selector: GetProjectRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object GetProjectRequest", fp)
}

func ParseGetProjectRequest_FieldPath(rawField string) (GetProjectRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildGetProjectRequest_FieldPath(fp)
}

func MustParseGetProjectRequest_FieldPath(rawField string) GetProjectRequest_FieldPath {
	fp, err := ParseGetProjectRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type GetProjectRequest_FieldTerminalPath struct {
	selector GetProjectRequest_FieldPathSelector
}

var _ GetProjectRequest_FieldPath = (*GetProjectRequest_FieldTerminalPath)(nil)

func (fp *GetProjectRequest_FieldTerminalPath) Selector() GetProjectRequest_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *GetProjectRequest_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *GetProjectRequest_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source GetProjectRequest
func (fp *GetProjectRequest_FieldTerminalPath) Get(source *GetProjectRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case GetProjectRequest_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case GetProjectRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case GetProjectRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", fp.selector))
		}
	}
	return
}

func (fp *GetProjectRequest_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*GetProjectRequest))
}

// GetSingle returns value pointed by specific field of from source GetProjectRequest
func (fp *GetProjectRequest_FieldTerminalPath) GetSingle(source *GetProjectRequest) (interface{}, bool) {
	switch fp.selector {
	case GetProjectRequest_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case GetProjectRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case GetProjectRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", fp.selector))
	}
}

func (fp *GetProjectRequest_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*GetProjectRequest))
}

// GetDefault returns a default value of the field type
func (fp *GetProjectRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case GetProjectRequest_FieldPathSelectorName:
		return (*project.Reference)(nil)
	case GetProjectRequest_FieldPathSelectorFieldMask:
		return (*project.Project_FieldMask)(nil)
	case GetProjectRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", fp.selector))
	}
}

func (fp *GetProjectRequest_FieldTerminalPath) ClearValue(item *GetProjectRequest) {
	if item != nil {
		switch fp.selector {
		case GetProjectRequest_FieldPathSelectorName:
			item.Name = nil
		case GetProjectRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case GetProjectRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", fp.selector))
		}
	}
}

func (fp *GetProjectRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*GetProjectRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *GetProjectRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == GetProjectRequest_FieldPathSelectorName ||
		fp.selector == GetProjectRequest_FieldPathSelectorFieldMask ||
		fp.selector == GetProjectRequest_FieldPathSelectorView
}

func (fp *GetProjectRequest_FieldTerminalPath) WithIValue(value interface{}) GetProjectRequest_FieldPathValue {
	switch fp.selector {
	case GetProjectRequest_FieldPathSelectorName:
		return &GetProjectRequest_FieldTerminalPathValue{GetProjectRequest_FieldTerminalPath: *fp, value: value.(*project.Reference)}
	case GetProjectRequest_FieldPathSelectorFieldMask:
		return &GetProjectRequest_FieldTerminalPathValue{GetProjectRequest_FieldTerminalPath: *fp, value: value.(*project.Project_FieldMask)}
	case GetProjectRequest_FieldPathSelectorView:
		return &GetProjectRequest_FieldTerminalPathValue{GetProjectRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", fp.selector))
	}
}

func (fp *GetProjectRequest_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *GetProjectRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) GetProjectRequest_FieldPathArrayOfValues {
	fpaov := &GetProjectRequest_FieldTerminalPathArrayOfValues{GetProjectRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case GetProjectRequest_FieldPathSelectorName:
		return &GetProjectRequest_FieldTerminalPathArrayOfValues{GetProjectRequest_FieldTerminalPath: *fp, values: values.([]*project.Reference)}
	case GetProjectRequest_FieldPathSelectorFieldMask:
		return &GetProjectRequest_FieldTerminalPathArrayOfValues{GetProjectRequest_FieldTerminalPath: *fp, values: values.([]*project.Project_FieldMask)}
	case GetProjectRequest_FieldPathSelectorView:
		return &GetProjectRequest_FieldTerminalPathArrayOfValues{GetProjectRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", fp.selector))
	}
	return fpaov
}

func (fp *GetProjectRequest_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *GetProjectRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) GetProjectRequest_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", fp.selector))
	}
}

func (fp *GetProjectRequest_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// GetProjectRequest_FieldPathValue allows storing values for GetProjectRequest fields according to their type
type GetProjectRequest_FieldPathValue interface {
	GetProjectRequest_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **GetProjectRequest)
	CompareWith(*GetProjectRequest) (cmp int, comparable bool)
}

func ParseGetProjectRequest_FieldPathValue(pathStr, valueStr string) (GetProjectRequest_FieldPathValue, error) {
	fp, err := ParseGetProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing GetProjectRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(GetProjectRequest_FieldPathValue), nil
}

func MustParseGetProjectRequest_FieldPathValue(pathStr, valueStr string) GetProjectRequest_FieldPathValue {
	fpv, err := ParseGetProjectRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type GetProjectRequest_FieldTerminalPathValue struct {
	GetProjectRequest_FieldTerminalPath
	value interface{}
}

var _ GetProjectRequest_FieldPathValue = (*GetProjectRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'GetProjectRequest' as interface{}
func (fpv *GetProjectRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *GetProjectRequest_FieldTerminalPathValue) AsNameValue() (*project.Reference, bool) {
	res, ok := fpv.value.(*project.Reference)
	return res, ok
}
func (fpv *GetProjectRequest_FieldTerminalPathValue) AsFieldMaskValue() (*project.Project_FieldMask, bool) {
	res, ok := fpv.value.(*project.Project_FieldMask)
	return res, ok
}
func (fpv *GetProjectRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object GetProjectRequest
func (fpv *GetProjectRequest_FieldTerminalPathValue) SetTo(target **GetProjectRequest) {
	if *target == nil {
		*target = new(GetProjectRequest)
	}
	switch fpv.selector {
	case GetProjectRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*project.Reference)
	case GetProjectRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*project.Project_FieldMask)
	case GetProjectRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", fpv.selector))
	}
}

func (fpv *GetProjectRequest_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*GetProjectRequest)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'GetProjectRequest_FieldTerminalPathValue' with the value under path in 'GetProjectRequest'.
func (fpv *GetProjectRequest_FieldTerminalPathValue) CompareWith(source *GetProjectRequest) (int, bool) {
	switch fpv.selector {
	case GetProjectRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*project.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case GetProjectRequest_FieldPathSelectorFieldMask:
		return 0, false
	case GetProjectRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for GetProjectRequest: %d", fpv.selector))
	}
}

func (fpv *GetProjectRequest_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*GetProjectRequest))
}

// GetProjectRequest_FieldPathArrayItemValue allows storing single item in Path-specific values for GetProjectRequest according to their type
// Present only for array (repeated) types.
type GetProjectRequest_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	GetProjectRequest_FieldPath
	ContainsValue(*GetProjectRequest) bool
}

// ParseGetProjectRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseGetProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) (GetProjectRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseGetProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing GetProjectRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(GetProjectRequest_FieldPathArrayItemValue), nil
}

func MustParseGetProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) GetProjectRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseGetProjectRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type GetProjectRequest_FieldTerminalPathArrayItemValue struct {
	GetProjectRequest_FieldTerminalPath
	value interface{}
}

var _ GetProjectRequest_FieldPathArrayItemValue = (*GetProjectRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object GetProjectRequest as interface{}
func (fpaiv *GetProjectRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *GetProjectRequest_FieldTerminalPathArrayItemValue) GetSingle(source *GetProjectRequest) (interface{}, bool) {
	return nil, false
}

func (fpaiv *GetProjectRequest_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*GetProjectRequest))
}

// Contains returns a boolean indicating if value that is being held is present in given 'GetProjectRequest'
func (fpaiv *GetProjectRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *GetProjectRequest) bool {
	slice := fpaiv.GetProjectRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// GetProjectRequest_FieldPathArrayOfValues allows storing slice of values for GetProjectRequest fields according to their type
type GetProjectRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	GetProjectRequest_FieldPath
}

func ParseGetProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (GetProjectRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseGetProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing GetProjectRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(GetProjectRequest_FieldPathArrayOfValues), nil
}

func MustParseGetProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) GetProjectRequest_FieldPathArrayOfValues {
	fpaov, err := ParseGetProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type GetProjectRequest_FieldTerminalPathArrayOfValues struct {
	GetProjectRequest_FieldTerminalPath
	values interface{}
}

var _ GetProjectRequest_FieldPathArrayOfValues = (*GetProjectRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *GetProjectRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case GetProjectRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*project.Reference) {
			values = append(values, v)
		}
	case GetProjectRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*project.Project_FieldMask) {
			values = append(values, v)
		}
	case GetProjectRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *GetProjectRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*project.Reference, bool) {
	res, ok := fpaov.values.([]*project.Reference)
	return res, ok
}
func (fpaov *GetProjectRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*project.Project_FieldMask, bool) {
	res, ok := fpaov.values.([]*project.Project_FieldMask)
	return res, ok
}
func (fpaov *GetProjectRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type BatchGetProjectsRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetProjectsRequest_FieldPathSelector
	Get(source *BatchGetProjectsRequest) []interface{}
	GetSingle(source *BatchGetProjectsRequest) (interface{}, bool)
	ClearValue(item *BatchGetProjectsRequest)

	// Those methods build corresponding BatchGetProjectsRequest_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) BatchGetProjectsRequest_FieldPathValue
	WithIArrayOfValues(values interface{}) BatchGetProjectsRequest_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) BatchGetProjectsRequest_FieldPathArrayItemValue
}

type BatchGetProjectsRequest_FieldPathSelector int32

const (
	BatchGetProjectsRequest_FieldPathSelectorNames     BatchGetProjectsRequest_FieldPathSelector = 0
	BatchGetProjectsRequest_FieldPathSelectorFieldMask BatchGetProjectsRequest_FieldPathSelector = 1
	BatchGetProjectsRequest_FieldPathSelectorView      BatchGetProjectsRequest_FieldPathSelector = 2
)

func (s BatchGetProjectsRequest_FieldPathSelector) String() string {
	switch s {
	case BatchGetProjectsRequest_FieldPathSelectorNames:
		return "names"
	case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case BatchGetProjectsRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", s))
	}
}

func BuildBatchGetProjectsRequest_FieldPath(fp gotenobject.RawFieldPath) (BatchGetProjectsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetProjectsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "names":
			return &BatchGetProjectsRequest_FieldTerminalPath{selector: BatchGetProjectsRequest_FieldPathSelectorNames}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &BatchGetProjectsRequest_FieldTerminalPath{selector: BatchGetProjectsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &BatchGetProjectsRequest_FieldTerminalPath{selector: BatchGetProjectsRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetProjectsRequest", fp)
}

func ParseBatchGetProjectsRequest_FieldPath(rawField string) (BatchGetProjectsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetProjectsRequest_FieldPath(fp)
}

func MustParseBatchGetProjectsRequest_FieldPath(rawField string) BatchGetProjectsRequest_FieldPath {
	fp, err := ParseBatchGetProjectsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetProjectsRequest_FieldTerminalPath struct {
	selector BatchGetProjectsRequest_FieldPathSelector
}

var _ BatchGetProjectsRequest_FieldPath = (*BatchGetProjectsRequest_FieldTerminalPath)(nil)

func (fp *BatchGetProjectsRequest_FieldTerminalPath) Selector() BatchGetProjectsRequest_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *BatchGetProjectsRequest_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *BatchGetProjectsRequest_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source BatchGetProjectsRequest
func (fp *BatchGetProjectsRequest_FieldTerminalPath) Get(source *BatchGetProjectsRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case BatchGetProjectsRequest_FieldPathSelectorNames:
			for _, value := range source.GetNames() {
				values = append(values, value)
			}
		case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case BatchGetProjectsRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", fp.selector))
		}
	}
	return
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*BatchGetProjectsRequest))
}

// GetSingle returns value pointed by specific field of from source BatchGetProjectsRequest
func (fp *BatchGetProjectsRequest_FieldTerminalPath) GetSingle(source *BatchGetProjectsRequest) (interface{}, bool) {
	switch fp.selector {
	case BatchGetProjectsRequest_FieldPathSelectorNames:
		res := source.GetNames()
		return res, res != nil
	case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case BatchGetProjectsRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", fp.selector))
	}
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*BatchGetProjectsRequest))
}

// GetDefault returns a default value of the field type
func (fp *BatchGetProjectsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetProjectsRequest_FieldPathSelectorNames:
		return ([]*project.Reference)(nil)
	case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
		return (*project.Project_FieldMask)(nil)
	case BatchGetProjectsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", fp.selector))
	}
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) ClearValue(item *BatchGetProjectsRequest) {
	if item != nil {
		switch fp.selector {
		case BatchGetProjectsRequest_FieldPathSelectorNames:
			item.Names = nil
		case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case BatchGetProjectsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", fp.selector))
		}
	}
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetProjectsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *BatchGetProjectsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == BatchGetProjectsRequest_FieldPathSelectorNames ||
		fp.selector == BatchGetProjectsRequest_FieldPathSelectorFieldMask ||
		fp.selector == BatchGetProjectsRequest_FieldPathSelectorView
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) WithIValue(value interface{}) BatchGetProjectsRequest_FieldPathValue {
	switch fp.selector {
	case BatchGetProjectsRequest_FieldPathSelectorNames:
		return &BatchGetProjectsRequest_FieldTerminalPathValue{BatchGetProjectsRequest_FieldTerminalPath: *fp, value: value.([]*project.Reference)}
	case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
		return &BatchGetProjectsRequest_FieldTerminalPathValue{BatchGetProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.Project_FieldMask)}
	case BatchGetProjectsRequest_FieldPathSelectorView:
		return &BatchGetProjectsRequest_FieldTerminalPathValue{BatchGetProjectsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", fp.selector))
	}
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetProjectsRequest_FieldPathArrayOfValues {
	fpaov := &BatchGetProjectsRequest_FieldTerminalPathArrayOfValues{BatchGetProjectsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetProjectsRequest_FieldPathSelectorNames:
		return &BatchGetProjectsRequest_FieldTerminalPathArrayOfValues{BatchGetProjectsRequest_FieldTerminalPath: *fp, values: values.([][]*project.Reference)}
	case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
		return &BatchGetProjectsRequest_FieldTerminalPathArrayOfValues{BatchGetProjectsRequest_FieldTerminalPath: *fp, values: values.([]*project.Project_FieldMask)}
	case BatchGetProjectsRequest_FieldPathSelectorView:
		return &BatchGetProjectsRequest_FieldTerminalPathArrayOfValues{BatchGetProjectsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", fp.selector))
	}
	return fpaov
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetProjectsRequest_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetProjectsRequest_FieldPathSelectorNames:
		return &BatchGetProjectsRequest_FieldTerminalPathArrayItemValue{BatchGetProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", fp.selector))
	}
}

func (fp *BatchGetProjectsRequest_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// BatchGetProjectsRequest_FieldPathValue allows storing values for BatchGetProjectsRequest fields according to their type
type BatchGetProjectsRequest_FieldPathValue interface {
	BatchGetProjectsRequest_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **BatchGetProjectsRequest)
	CompareWith(*BatchGetProjectsRequest) (cmp int, comparable bool)
}

func ParseBatchGetProjectsRequest_FieldPathValue(pathStr, valueStr string) (BatchGetProjectsRequest_FieldPathValue, error) {
	fp, err := ParseBatchGetProjectsRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing BatchGetProjectsRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(BatchGetProjectsRequest_FieldPathValue), nil
}

func MustParseBatchGetProjectsRequest_FieldPathValue(pathStr, valueStr string) BatchGetProjectsRequest_FieldPathValue {
	fpv, err := ParseBatchGetProjectsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetProjectsRequest_FieldTerminalPathValue struct {
	BatchGetProjectsRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetProjectsRequest_FieldPathValue = (*BatchGetProjectsRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetProjectsRequest' as interface{}
func (fpv *BatchGetProjectsRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetProjectsRequest_FieldTerminalPathValue) AsNamesValue() ([]*project.Reference, bool) {
	res, ok := fpv.value.([]*project.Reference)
	return res, ok
}
func (fpv *BatchGetProjectsRequest_FieldTerminalPathValue) AsFieldMaskValue() (*project.Project_FieldMask, bool) {
	res, ok := fpv.value.(*project.Project_FieldMask)
	return res, ok
}
func (fpv *BatchGetProjectsRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetProjectsRequest
func (fpv *BatchGetProjectsRequest_FieldTerminalPathValue) SetTo(target **BatchGetProjectsRequest) {
	if *target == nil {
		*target = new(BatchGetProjectsRequest)
	}
	switch fpv.selector {
	case BatchGetProjectsRequest_FieldPathSelectorNames:
		(*target).Names = fpv.value.([]*project.Reference)
	case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*project.Project_FieldMask)
	case BatchGetProjectsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", fpv.selector))
	}
}

func (fpv *BatchGetProjectsRequest_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*BatchGetProjectsRequest)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'BatchGetProjectsRequest_FieldTerminalPathValue' with the value under path in 'BatchGetProjectsRequest'.
func (fpv *BatchGetProjectsRequest_FieldTerminalPathValue) CompareWith(source *BatchGetProjectsRequest) (int, bool) {
	switch fpv.selector {
	case BatchGetProjectsRequest_FieldPathSelectorNames:
		return 0, false
	case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case BatchGetProjectsRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsRequest: %d", fpv.selector))
	}
}

func (fpv *BatchGetProjectsRequest_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*BatchGetProjectsRequest))
}

// BatchGetProjectsRequest_FieldPathArrayItemValue allows storing single item in Path-specific values for BatchGetProjectsRequest according to their type
// Present only for array (repeated) types.
type BatchGetProjectsRequest_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	BatchGetProjectsRequest_FieldPath
	ContainsValue(*BatchGetProjectsRequest) bool
}

// ParseBatchGetProjectsRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseBatchGetProjectsRequest_FieldPathArrayItemValue(pathStr, valueStr string) (BatchGetProjectsRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseBatchGetProjectsRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing BatchGetProjectsRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(BatchGetProjectsRequest_FieldPathArrayItemValue), nil
}

func MustParseBatchGetProjectsRequest_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetProjectsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetProjectsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetProjectsRequest_FieldTerminalPathArrayItemValue struct {
	BatchGetProjectsRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetProjectsRequest_FieldPathArrayItemValue = (*BatchGetProjectsRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetProjectsRequest as interface{}
func (fpaiv *BatchGetProjectsRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetProjectsRequest_FieldTerminalPathArrayItemValue) AsNamesItemValue() (*project.Reference, bool) {
	res, ok := fpaiv.value.(*project.Reference)
	return res, ok
}

func (fpaiv *BatchGetProjectsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetProjectsRequest) (interface{}, bool) {
	return nil, false
}

func (fpaiv *BatchGetProjectsRequest_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*BatchGetProjectsRequest))
}

// Contains returns a boolean indicating if value that is being held is present in given 'BatchGetProjectsRequest'
func (fpaiv *BatchGetProjectsRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *BatchGetProjectsRequest) bool {
	slice := fpaiv.BatchGetProjectsRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// BatchGetProjectsRequest_FieldPathArrayOfValues allows storing slice of values for BatchGetProjectsRequest fields according to their type
type BatchGetProjectsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetProjectsRequest_FieldPath
}

func ParseBatchGetProjectsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (BatchGetProjectsRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseBatchGetProjectsRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing BatchGetProjectsRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(BatchGetProjectsRequest_FieldPathArrayOfValues), nil
}

func MustParseBatchGetProjectsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetProjectsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetProjectsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetProjectsRequest_FieldTerminalPathArrayOfValues struct {
	BatchGetProjectsRequest_FieldTerminalPath
	values interface{}
}

var _ BatchGetProjectsRequest_FieldPathArrayOfValues = (*BatchGetProjectsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetProjectsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetProjectsRequest_FieldPathSelectorNames:
		for _, v := range fpaov.values.([][]*project.Reference) {
			values = append(values, v)
		}
	case BatchGetProjectsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*project.Project_FieldMask) {
			values = append(values, v)
		}
	case BatchGetProjectsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetProjectsRequest_FieldTerminalPathArrayOfValues) AsNamesArrayOfValues() ([][]*project.Reference, bool) {
	res, ok := fpaov.values.([][]*project.Reference)
	return res, ok
}
func (fpaov *BatchGetProjectsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*project.Project_FieldMask, bool) {
	res, ok := fpaov.values.([]*project.Project_FieldMask)
	return res, ok
}
func (fpaov *BatchGetProjectsRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type BatchGetProjectsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetProjectsResponse_FieldPathSelector
	Get(source *BatchGetProjectsResponse) []interface{}
	GetSingle(source *BatchGetProjectsResponse) (interface{}, bool)
	ClearValue(item *BatchGetProjectsResponse)

	// Those methods build corresponding BatchGetProjectsResponse_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) BatchGetProjectsResponse_FieldPathValue
	WithIArrayOfValues(values interface{}) BatchGetProjectsResponse_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) BatchGetProjectsResponse_FieldPathArrayItemValue
}

type BatchGetProjectsResponse_FieldPathSelector int32

const (
	BatchGetProjectsResponse_FieldPathSelectorProjects BatchGetProjectsResponse_FieldPathSelector = 0
	BatchGetProjectsResponse_FieldPathSelectorMissing  BatchGetProjectsResponse_FieldPathSelector = 1
)

func (s BatchGetProjectsResponse_FieldPathSelector) String() string {
	switch s {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		return "projects"
	case BatchGetProjectsResponse_FieldPathSelectorMissing:
		return "missing"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", s))
	}
}

func BuildBatchGetProjectsResponse_FieldPath(fp gotenobject.RawFieldPath) (BatchGetProjectsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetProjectsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "projects":
			return &BatchGetProjectsResponse_FieldTerminalPath{selector: BatchGetProjectsResponse_FieldPathSelectorProjects}, nil
		case "missing":
			return &BatchGetProjectsResponse_FieldTerminalPath{selector: BatchGetProjectsResponse_FieldPathSelectorMissing}, nil
		}
	} else {
		switch fp[0] {
		case "projects":
			if subpath, err := project.BuildProject_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &BatchGetProjectsResponse_FieldSubPath{selector: BatchGetProjectsResponse_FieldPathSelectorProjects, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetProjectsResponse", fp)
}

func ParseBatchGetProjectsResponse_FieldPath(rawField string) (BatchGetProjectsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetProjectsResponse_FieldPath(fp)
}

func MustParseBatchGetProjectsResponse_FieldPath(rawField string) BatchGetProjectsResponse_FieldPath {
	fp, err := ParseBatchGetProjectsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetProjectsResponse_FieldTerminalPath struct {
	selector BatchGetProjectsResponse_FieldPathSelector
}

var _ BatchGetProjectsResponse_FieldPath = (*BatchGetProjectsResponse_FieldTerminalPath)(nil)

func (fp *BatchGetProjectsResponse_FieldTerminalPath) Selector() BatchGetProjectsResponse_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *BatchGetProjectsResponse_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *BatchGetProjectsResponse_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source BatchGetProjectsResponse
func (fp *BatchGetProjectsResponse_FieldTerminalPath) Get(source *BatchGetProjectsResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case BatchGetProjectsResponse_FieldPathSelectorProjects:
			for _, value := range source.GetProjects() {
				values = append(values, value)
			}
		case BatchGetProjectsResponse_FieldPathSelectorMissing:
			for _, value := range source.GetMissing() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fp.selector))
		}
	}
	return
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*BatchGetProjectsResponse))
}

// GetSingle returns value pointed by specific field of from source BatchGetProjectsResponse
func (fp *BatchGetProjectsResponse_FieldTerminalPath) GetSingle(source *BatchGetProjectsResponse) (interface{}, bool) {
	switch fp.selector {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		res := source.GetProjects()
		return res, res != nil
	case BatchGetProjectsResponse_FieldPathSelectorMissing:
		res := source.GetMissing()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fp.selector))
	}
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*BatchGetProjectsResponse))
}

// GetDefault returns a default value of the field type
func (fp *BatchGetProjectsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		return ([]*project.Project)(nil)
	case BatchGetProjectsResponse_FieldPathSelectorMissing:
		return ([]*project.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fp.selector))
	}
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) ClearValue(item *BatchGetProjectsResponse) {
	if item != nil {
		switch fp.selector {
		case BatchGetProjectsResponse_FieldPathSelectorProjects:
			item.Projects = nil
		case BatchGetProjectsResponse_FieldPathSelectorMissing:
			item.Missing = nil
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fp.selector))
		}
	}
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetProjectsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *BatchGetProjectsResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == BatchGetProjectsResponse_FieldPathSelectorMissing
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) WithIValue(value interface{}) BatchGetProjectsResponse_FieldPathValue {
	switch fp.selector {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		return &BatchGetProjectsResponse_FieldTerminalPathValue{BatchGetProjectsResponse_FieldTerminalPath: *fp, value: value.([]*project.Project)}
	case BatchGetProjectsResponse_FieldPathSelectorMissing:
		return &BatchGetProjectsResponse_FieldTerminalPathValue{BatchGetProjectsResponse_FieldTerminalPath: *fp, value: value.([]*project.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fp.selector))
	}
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetProjectsResponse_FieldPathArrayOfValues {
	fpaov := &BatchGetProjectsResponse_FieldTerminalPathArrayOfValues{BatchGetProjectsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		return &BatchGetProjectsResponse_FieldTerminalPathArrayOfValues{BatchGetProjectsResponse_FieldTerminalPath: *fp, values: values.([][]*project.Project)}
	case BatchGetProjectsResponse_FieldPathSelectorMissing:
		return &BatchGetProjectsResponse_FieldTerminalPathArrayOfValues{BatchGetProjectsResponse_FieldTerminalPath: *fp, values: values.([][]*project.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fp.selector))
	}
	return fpaov
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetProjectsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		return &BatchGetProjectsResponse_FieldTerminalPathArrayItemValue{BatchGetProjectsResponse_FieldTerminalPath: *fp, value: value.(*project.Project)}
	case BatchGetProjectsResponse_FieldPathSelectorMissing:
		return &BatchGetProjectsResponse_FieldTerminalPathArrayItemValue{BatchGetProjectsResponse_FieldTerminalPath: *fp, value: value.(*project.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fp.selector))
	}
}

func (fp *BatchGetProjectsResponse_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type BatchGetProjectsResponse_FieldSubPath struct {
	selector BatchGetProjectsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ BatchGetProjectsResponse_FieldPath = (*BatchGetProjectsResponse_FieldSubPath)(nil)

func (fps *BatchGetProjectsResponse_FieldSubPath) Selector() BatchGetProjectsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *BatchGetProjectsResponse_FieldSubPath) AsProjectsSubPath() (project.Project_FieldPath, bool) {
	res, ok := fps.subPath.(project.Project_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *BatchGetProjectsResponse_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *BatchGetProjectsResponse_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source BatchGetProjectsResponse
func (fps *BatchGetProjectsResponse_FieldSubPath) Get(source *BatchGetProjectsResponse) (values []interface{}) {
	if asProjectFieldPath, ok := fps.AsProjectsSubPath(); ok {
		for _, item := range source.GetProjects() {
			values = append(values, asProjectFieldPath.Get(item)...)
		}
	} else {
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fps.selector))
	}
	return
}

func (fps *BatchGetProjectsResponse_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*BatchGetProjectsResponse))
}

// GetSingle returns value of selected field from source BatchGetProjectsResponse
func (fps *BatchGetProjectsResponse_FieldSubPath) GetSingle(source *BatchGetProjectsResponse) (interface{}, bool) {
	switch fps.selector {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		if len(source.GetProjects()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetProjects()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fps.selector))
	}
}

func (fps *BatchGetProjectsResponse_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*BatchGetProjectsResponse))
}

// GetDefault returns a default value of the field type
func (fps *BatchGetProjectsResponse_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *BatchGetProjectsResponse_FieldSubPath) ClearValue(item *BatchGetProjectsResponse) {
	if item != nil {
		switch fps.selector {
		case BatchGetProjectsResponse_FieldPathSelectorProjects:
			for _, subItem := range item.Projects {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fps.selector))
		}
	}
}

func (fps *BatchGetProjectsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*BatchGetProjectsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fps *BatchGetProjectsResponse_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *BatchGetProjectsResponse_FieldSubPath) WithIValue(value interface{}) BatchGetProjectsResponse_FieldPathValue {
	return &BatchGetProjectsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *BatchGetProjectsResponse_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *BatchGetProjectsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) BatchGetProjectsResponse_FieldPathArrayOfValues {
	return &BatchGetProjectsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *BatchGetProjectsResponse_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *BatchGetProjectsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) BatchGetProjectsResponse_FieldPathArrayItemValue {
	return &BatchGetProjectsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *BatchGetProjectsResponse_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// BatchGetProjectsResponse_FieldPathValue allows storing values for BatchGetProjectsResponse fields according to their type
type BatchGetProjectsResponse_FieldPathValue interface {
	BatchGetProjectsResponse_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **BatchGetProjectsResponse)
	CompareWith(*BatchGetProjectsResponse) (cmp int, comparable bool)
}

func ParseBatchGetProjectsResponse_FieldPathValue(pathStr, valueStr string) (BatchGetProjectsResponse_FieldPathValue, error) {
	fp, err := ParseBatchGetProjectsResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing BatchGetProjectsResponse field path value from %s: %v", valueStr, err)
	}
	return fpv.(BatchGetProjectsResponse_FieldPathValue), nil
}

func MustParseBatchGetProjectsResponse_FieldPathValue(pathStr, valueStr string) BatchGetProjectsResponse_FieldPathValue {
	fpv, err := ParseBatchGetProjectsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetProjectsResponse_FieldTerminalPathValue struct {
	BatchGetProjectsResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetProjectsResponse_FieldPathValue = (*BatchGetProjectsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetProjectsResponse' as interface{}
func (fpv *BatchGetProjectsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetProjectsResponse_FieldTerminalPathValue) AsProjectsValue() ([]*project.Project, bool) {
	res, ok := fpv.value.([]*project.Project)
	return res, ok
}
func (fpv *BatchGetProjectsResponse_FieldTerminalPathValue) AsMissingValue() ([]*project.Reference, bool) {
	res, ok := fpv.value.([]*project.Reference)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetProjectsResponse
func (fpv *BatchGetProjectsResponse_FieldTerminalPathValue) SetTo(target **BatchGetProjectsResponse) {
	if *target == nil {
		*target = new(BatchGetProjectsResponse)
	}
	switch fpv.selector {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		(*target).Projects = fpv.value.([]*project.Project)
	case BatchGetProjectsResponse_FieldPathSelectorMissing:
		(*target).Missing = fpv.value.([]*project.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fpv.selector))
	}
}

func (fpv *BatchGetProjectsResponse_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*BatchGetProjectsResponse)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'BatchGetProjectsResponse_FieldTerminalPathValue' with the value under path in 'BatchGetProjectsResponse'.
func (fpv *BatchGetProjectsResponse_FieldTerminalPathValue) CompareWith(source *BatchGetProjectsResponse) (int, bool) {
	switch fpv.selector {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		return 0, false
	case BatchGetProjectsResponse_FieldPathSelectorMissing:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fpv.selector))
	}
}

func (fpv *BatchGetProjectsResponse_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*BatchGetProjectsResponse))
}

type BatchGetProjectsResponse_FieldSubPathValue struct {
	BatchGetProjectsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ BatchGetProjectsResponse_FieldPathValue = (*BatchGetProjectsResponse_FieldSubPathValue)(nil)

func (fpvs *BatchGetProjectsResponse_FieldSubPathValue) AsProjectsPathValue() (project.Project_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(project.Project_FieldPathValue)
	return res, ok
}

func (fpvs *BatchGetProjectsResponse_FieldSubPathValue) SetTo(target **BatchGetProjectsResponse) {
	if *target == nil {
		*target = new(BatchGetProjectsResponse)
	}
	switch fpvs.Selector() {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fpvs.Selector()))
	}
}

func (fpvs *BatchGetProjectsResponse_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*BatchGetProjectsResponse)
	fpvs.SetTo(&typedObject)
}

func (fpvs *BatchGetProjectsResponse_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *BatchGetProjectsResponse_FieldSubPathValue) CompareWith(source *BatchGetProjectsResponse) (int, bool) {
	switch fpvs.Selector() {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fpvs.Selector()))
	}
}

func (fpvs *BatchGetProjectsResponse_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*BatchGetProjectsResponse))
}

// BatchGetProjectsResponse_FieldPathArrayItemValue allows storing single item in Path-specific values for BatchGetProjectsResponse according to their type
// Present only for array (repeated) types.
type BatchGetProjectsResponse_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	BatchGetProjectsResponse_FieldPath
	ContainsValue(*BatchGetProjectsResponse) bool
}

// ParseBatchGetProjectsResponse_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseBatchGetProjectsResponse_FieldPathArrayItemValue(pathStr, valueStr string) (BatchGetProjectsResponse_FieldPathArrayItemValue, error) {
	fp, err := ParseBatchGetProjectsResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing BatchGetProjectsResponse field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(BatchGetProjectsResponse_FieldPathArrayItemValue), nil
}

func MustParseBatchGetProjectsResponse_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetProjectsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetProjectsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetProjectsResponse_FieldTerminalPathArrayItemValue struct {
	BatchGetProjectsResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetProjectsResponse_FieldPathArrayItemValue = (*BatchGetProjectsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetProjectsResponse as interface{}
func (fpaiv *BatchGetProjectsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetProjectsResponse_FieldTerminalPathArrayItemValue) AsProjectsItemValue() (*project.Project, bool) {
	res, ok := fpaiv.value.(*project.Project)
	return res, ok
}
func (fpaiv *BatchGetProjectsResponse_FieldTerminalPathArrayItemValue) AsMissingItemValue() (*project.Reference, bool) {
	res, ok := fpaiv.value.(*project.Reference)
	return res, ok
}

func (fpaiv *BatchGetProjectsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetProjectsResponse) (interface{}, bool) {
	return nil, false
}

func (fpaiv *BatchGetProjectsResponse_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*BatchGetProjectsResponse))
}

// Contains returns a boolean indicating if value that is being held is present in given 'BatchGetProjectsResponse'
func (fpaiv *BatchGetProjectsResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *BatchGetProjectsResponse) bool {
	slice := fpaiv.BatchGetProjectsResponse_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type BatchGetProjectsResponse_FieldSubPathArrayItemValue struct {
	BatchGetProjectsResponse_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *BatchGetProjectsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *BatchGetProjectsResponse_FieldSubPathArrayItemValue) AsProjectsPathItemValue() (project.Project_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(project.Project_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'BatchGetProjectsResponse'
func (fpaivs *BatchGetProjectsResponse_FieldSubPathArrayItemValue) ContainsValue(source *BatchGetProjectsResponse) bool {
	switch fpaivs.Selector() {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetProjectsResponse: %d", fpaivs.Selector()))
	}
}

// BatchGetProjectsResponse_FieldPathArrayOfValues allows storing slice of values for BatchGetProjectsResponse fields according to their type
type BatchGetProjectsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetProjectsResponse_FieldPath
}

func ParseBatchGetProjectsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) (BatchGetProjectsResponse_FieldPathArrayOfValues, error) {
	fp, err := ParseBatchGetProjectsResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing BatchGetProjectsResponse field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(BatchGetProjectsResponse_FieldPathArrayOfValues), nil
}

func MustParseBatchGetProjectsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetProjectsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetProjectsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetProjectsResponse_FieldTerminalPathArrayOfValues struct {
	BatchGetProjectsResponse_FieldTerminalPath
	values interface{}
}

var _ BatchGetProjectsResponse_FieldPathArrayOfValues = (*BatchGetProjectsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetProjectsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetProjectsResponse_FieldPathSelectorProjects:
		for _, v := range fpaov.values.([][]*project.Project) {
			values = append(values, v)
		}
	case BatchGetProjectsResponse_FieldPathSelectorMissing:
		for _, v := range fpaov.values.([][]*project.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetProjectsResponse_FieldTerminalPathArrayOfValues) AsProjectsArrayOfValues() ([][]*project.Project, bool) {
	res, ok := fpaov.values.([][]*project.Project)
	return res, ok
}
func (fpaov *BatchGetProjectsResponse_FieldTerminalPathArrayOfValues) AsMissingArrayOfValues() ([][]*project.Reference, bool) {
	res, ok := fpaov.values.([][]*project.Reference)
	return res, ok
}

type BatchGetProjectsResponse_FieldSubPathArrayOfValues struct {
	BatchGetProjectsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ BatchGetProjectsResponse_FieldPathArrayOfValues = (*BatchGetProjectsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *BatchGetProjectsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *BatchGetProjectsResponse_FieldSubPathArrayOfValues) AsProjectsPathArrayOfValues() (project.Project_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(project.Project_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ListProjectsRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() ListProjectsRequest_FieldPathSelector
	Get(source *ListProjectsRequest) []interface{}
	GetSingle(source *ListProjectsRequest) (interface{}, bool)
	ClearValue(item *ListProjectsRequest)

	// Those methods build corresponding ListProjectsRequest_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ListProjectsRequest_FieldPathValue
	WithIArrayOfValues(values interface{}) ListProjectsRequest_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ListProjectsRequest_FieldPathArrayItemValue
}

type ListProjectsRequest_FieldPathSelector int32

const (
	ListProjectsRequest_FieldPathSelectorPageSize  ListProjectsRequest_FieldPathSelector = 0
	ListProjectsRequest_FieldPathSelectorPageToken ListProjectsRequest_FieldPathSelector = 1
	ListProjectsRequest_FieldPathSelectorOrderBy   ListProjectsRequest_FieldPathSelector = 2
	ListProjectsRequest_FieldPathSelectorFilter    ListProjectsRequest_FieldPathSelector = 3
	ListProjectsRequest_FieldPathSelectorFieldMask ListProjectsRequest_FieldPathSelector = 4
	ListProjectsRequest_FieldPathSelectorView      ListProjectsRequest_FieldPathSelector = 5
)

func (s ListProjectsRequest_FieldPathSelector) String() string {
	switch s {
	case ListProjectsRequest_FieldPathSelectorPageSize:
		return "page_size"
	case ListProjectsRequest_FieldPathSelectorPageToken:
		return "page_token"
	case ListProjectsRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case ListProjectsRequest_FieldPathSelectorFilter:
		return "filter"
	case ListProjectsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case ListProjectsRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", s))
	}
}

func BuildListProjectsRequest_FieldPath(fp gotenobject.RawFieldPath) (ListProjectsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListProjectsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "page_size", "pageSize", "page-size":
			return &ListProjectsRequest_FieldTerminalPath{selector: ListProjectsRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &ListProjectsRequest_FieldTerminalPath{selector: ListProjectsRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &ListProjectsRequest_FieldTerminalPath{selector: ListProjectsRequest_FieldPathSelectorOrderBy}, nil
		case "filter":
			return &ListProjectsRequest_FieldTerminalPath{selector: ListProjectsRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &ListProjectsRequest_FieldTerminalPath{selector: ListProjectsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &ListProjectsRequest_FieldTerminalPath{selector: ListProjectsRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListProjectsRequest", fp)
}

func ParseListProjectsRequest_FieldPath(rawField string) (ListProjectsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListProjectsRequest_FieldPath(fp)
}

func MustParseListProjectsRequest_FieldPath(rawField string) ListProjectsRequest_FieldPath {
	fp, err := ParseListProjectsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListProjectsRequest_FieldTerminalPath struct {
	selector ListProjectsRequest_FieldPathSelector
}

var _ ListProjectsRequest_FieldPath = (*ListProjectsRequest_FieldTerminalPath)(nil)

func (fp *ListProjectsRequest_FieldTerminalPath) Selector() ListProjectsRequest_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ListProjectsRequest_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ListProjectsRequest_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ListProjectsRequest
func (fp *ListProjectsRequest_FieldTerminalPath) Get(source *ListProjectsRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListProjectsRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case ListProjectsRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case ListProjectsRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case ListProjectsRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case ListProjectsRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case ListProjectsRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", fp.selector))
		}
	}
	return
}

func (fp *ListProjectsRequest_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ListProjectsRequest))
}

// GetSingle returns value pointed by specific field of from source ListProjectsRequest
func (fp *ListProjectsRequest_FieldTerminalPath) GetSingle(source *ListProjectsRequest) (interface{}, bool) {
	switch fp.selector {
	case ListProjectsRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case ListProjectsRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case ListProjectsRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case ListProjectsRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case ListProjectsRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case ListProjectsRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", fp.selector))
	}
}

func (fp *ListProjectsRequest_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ListProjectsRequest))
}

// GetDefault returns a default value of the field type
func (fp *ListProjectsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListProjectsRequest_FieldPathSelectorPageSize:
		return int32(0)
	case ListProjectsRequest_FieldPathSelectorPageToken:
		return (*project.PagerCursor)(nil)
	case ListProjectsRequest_FieldPathSelectorOrderBy:
		return (*project.OrderBy)(nil)
	case ListProjectsRequest_FieldPathSelectorFilter:
		return (*project.Filter)(nil)
	case ListProjectsRequest_FieldPathSelectorFieldMask:
		return (*project.Project_FieldMask)(nil)
	case ListProjectsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", fp.selector))
	}
}

func (fp *ListProjectsRequest_FieldTerminalPath) ClearValue(item *ListProjectsRequest) {
	if item != nil {
		switch fp.selector {
		case ListProjectsRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case ListProjectsRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case ListProjectsRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case ListProjectsRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case ListProjectsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case ListProjectsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", fp.selector))
		}
	}
}

func (fp *ListProjectsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListProjectsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListProjectsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListProjectsRequest_FieldPathSelectorPageSize ||
		fp.selector == ListProjectsRequest_FieldPathSelectorPageToken ||
		fp.selector == ListProjectsRequest_FieldPathSelectorOrderBy ||
		fp.selector == ListProjectsRequest_FieldPathSelectorFilter ||
		fp.selector == ListProjectsRequest_FieldPathSelectorFieldMask ||
		fp.selector == ListProjectsRequest_FieldPathSelectorView
}

func (fp *ListProjectsRequest_FieldTerminalPath) WithIValue(value interface{}) ListProjectsRequest_FieldPathValue {
	switch fp.selector {
	case ListProjectsRequest_FieldPathSelectorPageSize:
		return &ListProjectsRequest_FieldTerminalPathValue{ListProjectsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case ListProjectsRequest_FieldPathSelectorPageToken:
		return &ListProjectsRequest_FieldTerminalPathValue{ListProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.PagerCursor)}
	case ListProjectsRequest_FieldPathSelectorOrderBy:
		return &ListProjectsRequest_FieldTerminalPathValue{ListProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.OrderBy)}
	case ListProjectsRequest_FieldPathSelectorFilter:
		return &ListProjectsRequest_FieldTerminalPathValue{ListProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.Filter)}
	case ListProjectsRequest_FieldPathSelectorFieldMask:
		return &ListProjectsRequest_FieldTerminalPathValue{ListProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.Project_FieldMask)}
	case ListProjectsRequest_FieldPathSelectorView:
		return &ListProjectsRequest_FieldTerminalPathValue{ListProjectsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", fp.selector))
	}
}

func (fp *ListProjectsRequest_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ListProjectsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListProjectsRequest_FieldPathArrayOfValues {
	fpaov := &ListProjectsRequest_FieldTerminalPathArrayOfValues{ListProjectsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListProjectsRequest_FieldPathSelectorPageSize:
		return &ListProjectsRequest_FieldTerminalPathArrayOfValues{ListProjectsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListProjectsRequest_FieldPathSelectorPageToken:
		return &ListProjectsRequest_FieldTerminalPathArrayOfValues{ListProjectsRequest_FieldTerminalPath: *fp, values: values.([]*project.PagerCursor)}
	case ListProjectsRequest_FieldPathSelectorOrderBy:
		return &ListProjectsRequest_FieldTerminalPathArrayOfValues{ListProjectsRequest_FieldTerminalPath: *fp, values: values.([]*project.OrderBy)}
	case ListProjectsRequest_FieldPathSelectorFilter:
		return &ListProjectsRequest_FieldTerminalPathArrayOfValues{ListProjectsRequest_FieldTerminalPath: *fp, values: values.([]*project.Filter)}
	case ListProjectsRequest_FieldPathSelectorFieldMask:
		return &ListProjectsRequest_FieldTerminalPathArrayOfValues{ListProjectsRequest_FieldTerminalPath: *fp, values: values.([]*project.Project_FieldMask)}
	case ListProjectsRequest_FieldPathSelectorView:
		return &ListProjectsRequest_FieldTerminalPathArrayOfValues{ListProjectsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", fp.selector))
	}
	return fpaov
}

func (fp *ListProjectsRequest_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ListProjectsRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListProjectsRequest_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", fp.selector))
	}
}

func (fp *ListProjectsRequest_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// ListProjectsRequest_FieldPathValue allows storing values for ListProjectsRequest fields according to their type
type ListProjectsRequest_FieldPathValue interface {
	ListProjectsRequest_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ListProjectsRequest)
	CompareWith(*ListProjectsRequest) (cmp int, comparable bool)
}

func ParseListProjectsRequest_FieldPathValue(pathStr, valueStr string) (ListProjectsRequest_FieldPathValue, error) {
	fp, err := ParseListProjectsRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ListProjectsRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(ListProjectsRequest_FieldPathValue), nil
}

func MustParseListProjectsRequest_FieldPathValue(pathStr, valueStr string) ListProjectsRequest_FieldPathValue {
	fpv, err := ParseListProjectsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListProjectsRequest_FieldTerminalPathValue struct {
	ListProjectsRequest_FieldTerminalPath
	value interface{}
}

var _ ListProjectsRequest_FieldPathValue = (*ListProjectsRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListProjectsRequest' as interface{}
func (fpv *ListProjectsRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListProjectsRequest_FieldTerminalPathValue) AsPageSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListProjectsRequest_FieldTerminalPathValue) AsPageTokenValue() (*project.PagerCursor, bool) {
	res, ok := fpv.value.(*project.PagerCursor)
	return res, ok
}
func (fpv *ListProjectsRequest_FieldTerminalPathValue) AsOrderByValue() (*project.OrderBy, bool) {
	res, ok := fpv.value.(*project.OrderBy)
	return res, ok
}
func (fpv *ListProjectsRequest_FieldTerminalPathValue) AsFilterValue() (*project.Filter, bool) {
	res, ok := fpv.value.(*project.Filter)
	return res, ok
}
func (fpv *ListProjectsRequest_FieldTerminalPathValue) AsFieldMaskValue() (*project.Project_FieldMask, bool) {
	res, ok := fpv.value.(*project.Project_FieldMask)
	return res, ok
}
func (fpv *ListProjectsRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object ListProjectsRequest
func (fpv *ListProjectsRequest_FieldTerminalPathValue) SetTo(target **ListProjectsRequest) {
	if *target == nil {
		*target = new(ListProjectsRequest)
	}
	switch fpv.selector {
	case ListProjectsRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case ListProjectsRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*project.PagerCursor)
	case ListProjectsRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*project.OrderBy)
	case ListProjectsRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*project.Filter)
	case ListProjectsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*project.Project_FieldMask)
	case ListProjectsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", fpv.selector))
	}
}

func (fpv *ListProjectsRequest_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ListProjectsRequest)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ListProjectsRequest_FieldTerminalPathValue' with the value under path in 'ListProjectsRequest'.
func (fpv *ListProjectsRequest_FieldTerminalPathValue) CompareWith(source *ListProjectsRequest) (int, bool) {
	switch fpv.selector {
	case ListProjectsRequest_FieldPathSelectorPageSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetPageSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ListProjectsRequest_FieldPathSelectorPageToken:
		return 0, false
	case ListProjectsRequest_FieldPathSelectorOrderBy:
		return 0, false
	case ListProjectsRequest_FieldPathSelectorFilter:
		return 0, false
	case ListProjectsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case ListProjectsRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsRequest: %d", fpv.selector))
	}
}

func (fpv *ListProjectsRequest_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ListProjectsRequest))
}

// ListProjectsRequest_FieldPathArrayItemValue allows storing single item in Path-specific values for ListProjectsRequest according to their type
// Present only for array (repeated) types.
type ListProjectsRequest_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ListProjectsRequest_FieldPath
	ContainsValue(*ListProjectsRequest) bool
}

// ParseListProjectsRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseListProjectsRequest_FieldPathArrayItemValue(pathStr, valueStr string) (ListProjectsRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseListProjectsRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ListProjectsRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ListProjectsRequest_FieldPathArrayItemValue), nil
}

func MustParseListProjectsRequest_FieldPathArrayItemValue(pathStr, valueStr string) ListProjectsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseListProjectsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListProjectsRequest_FieldTerminalPathArrayItemValue struct {
	ListProjectsRequest_FieldTerminalPath
	value interface{}
}

var _ ListProjectsRequest_FieldPathArrayItemValue = (*ListProjectsRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListProjectsRequest as interface{}
func (fpaiv *ListProjectsRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ListProjectsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ListProjectsRequest) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ListProjectsRequest_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ListProjectsRequest))
}

// Contains returns a boolean indicating if value that is being held is present in given 'ListProjectsRequest'
func (fpaiv *ListProjectsRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *ListProjectsRequest) bool {
	slice := fpaiv.ListProjectsRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// ListProjectsRequest_FieldPathArrayOfValues allows storing slice of values for ListProjectsRequest fields according to their type
type ListProjectsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListProjectsRequest_FieldPath
}

func ParseListProjectsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (ListProjectsRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseListProjectsRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ListProjectsRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ListProjectsRequest_FieldPathArrayOfValues), nil
}

func MustParseListProjectsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ListProjectsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseListProjectsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListProjectsRequest_FieldTerminalPathArrayOfValues struct {
	ListProjectsRequest_FieldTerminalPath
	values interface{}
}

var _ ListProjectsRequest_FieldPathArrayOfValues = (*ListProjectsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListProjectsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListProjectsRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListProjectsRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*project.PagerCursor) {
			values = append(values, v)
		}
	case ListProjectsRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*project.OrderBy) {
			values = append(values, v)
		}
	case ListProjectsRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*project.Filter) {
			values = append(values, v)
		}
	case ListProjectsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*project.Project_FieldMask) {
			values = append(values, v)
		}
	case ListProjectsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListProjectsRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListProjectsRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*project.PagerCursor, bool) {
	res, ok := fpaov.values.([]*project.PagerCursor)
	return res, ok
}
func (fpaov *ListProjectsRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*project.OrderBy, bool) {
	res, ok := fpaov.values.([]*project.OrderBy)
	return res, ok
}
func (fpaov *ListProjectsRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*project.Filter, bool) {
	res, ok := fpaov.values.([]*project.Filter)
	return res, ok
}
func (fpaov *ListProjectsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*project.Project_FieldMask, bool) {
	res, ok := fpaov.values.([]*project.Project_FieldMask)
	return res, ok
}
func (fpaov *ListProjectsRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ListProjectsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() ListProjectsResponse_FieldPathSelector
	Get(source *ListProjectsResponse) []interface{}
	GetSingle(source *ListProjectsResponse) (interface{}, bool)
	ClearValue(item *ListProjectsResponse)

	// Those methods build corresponding ListProjectsResponse_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ListProjectsResponse_FieldPathValue
	WithIArrayOfValues(values interface{}) ListProjectsResponse_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ListProjectsResponse_FieldPathArrayItemValue
}

type ListProjectsResponse_FieldPathSelector int32

const (
	ListProjectsResponse_FieldPathSelectorProjects      ListProjectsResponse_FieldPathSelector = 0
	ListProjectsResponse_FieldPathSelectorPrevPageToken ListProjectsResponse_FieldPathSelector = 1
	ListProjectsResponse_FieldPathSelectorNextPageToken ListProjectsResponse_FieldPathSelector = 2
)

func (s ListProjectsResponse_FieldPathSelector) String() string {
	switch s {
	case ListProjectsResponse_FieldPathSelectorProjects:
		return "projects"
	case ListProjectsResponse_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case ListProjectsResponse_FieldPathSelectorNextPageToken:
		return "next_page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", s))
	}
}

func BuildListProjectsResponse_FieldPath(fp gotenobject.RawFieldPath) (ListProjectsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListProjectsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "projects":
			return &ListProjectsResponse_FieldTerminalPath{selector: ListProjectsResponse_FieldPathSelectorProjects}, nil
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &ListProjectsResponse_FieldTerminalPath{selector: ListProjectsResponse_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &ListProjectsResponse_FieldTerminalPath{selector: ListProjectsResponse_FieldPathSelectorNextPageToken}, nil
		}
	} else {
		switch fp[0] {
		case "projects":
			if subpath, err := project.BuildProject_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListProjectsResponse_FieldSubPath{selector: ListProjectsResponse_FieldPathSelectorProjects, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListProjectsResponse", fp)
}

func ParseListProjectsResponse_FieldPath(rawField string) (ListProjectsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListProjectsResponse_FieldPath(fp)
}

func MustParseListProjectsResponse_FieldPath(rawField string) ListProjectsResponse_FieldPath {
	fp, err := ParseListProjectsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListProjectsResponse_FieldTerminalPath struct {
	selector ListProjectsResponse_FieldPathSelector
}

var _ ListProjectsResponse_FieldPath = (*ListProjectsResponse_FieldTerminalPath)(nil)

func (fp *ListProjectsResponse_FieldTerminalPath) Selector() ListProjectsResponse_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ListProjectsResponse_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ListProjectsResponse_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ListProjectsResponse
func (fp *ListProjectsResponse_FieldTerminalPath) Get(source *ListProjectsResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListProjectsResponse_FieldPathSelectorProjects:
			for _, value := range source.GetProjects() {
				values = append(values, value)
			}
		case ListProjectsResponse_FieldPathSelectorPrevPageToken:
			if source.PrevPageToken != nil {
				values = append(values, source.PrevPageToken)
			}
		case ListProjectsResponse_FieldPathSelectorNextPageToken:
			if source.NextPageToken != nil {
				values = append(values, source.NextPageToken)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fp.selector))
		}
	}
	return
}

func (fp *ListProjectsResponse_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ListProjectsResponse))
}

// GetSingle returns value pointed by specific field of from source ListProjectsResponse
func (fp *ListProjectsResponse_FieldTerminalPath) GetSingle(source *ListProjectsResponse) (interface{}, bool) {
	switch fp.selector {
	case ListProjectsResponse_FieldPathSelectorProjects:
		res := source.GetProjects()
		return res, res != nil
	case ListProjectsResponse_FieldPathSelectorPrevPageToken:
		res := source.GetPrevPageToken()
		return res, res != nil
	case ListProjectsResponse_FieldPathSelectorNextPageToken:
		res := source.GetNextPageToken()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fp.selector))
	}
}

func (fp *ListProjectsResponse_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ListProjectsResponse))
}

// GetDefault returns a default value of the field type
func (fp *ListProjectsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListProjectsResponse_FieldPathSelectorProjects:
		return ([]*project.Project)(nil)
	case ListProjectsResponse_FieldPathSelectorPrevPageToken:
		return (*project.PagerCursor)(nil)
	case ListProjectsResponse_FieldPathSelectorNextPageToken:
		return (*project.PagerCursor)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fp.selector))
	}
}

func (fp *ListProjectsResponse_FieldTerminalPath) ClearValue(item *ListProjectsResponse) {
	if item != nil {
		switch fp.selector {
		case ListProjectsResponse_FieldPathSelectorProjects:
			item.Projects = nil
		case ListProjectsResponse_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case ListProjectsResponse_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fp.selector))
		}
	}
}

func (fp *ListProjectsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListProjectsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListProjectsResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListProjectsResponse_FieldPathSelectorPrevPageToken ||
		fp.selector == ListProjectsResponse_FieldPathSelectorNextPageToken
}

func (fp *ListProjectsResponse_FieldTerminalPath) WithIValue(value interface{}) ListProjectsResponse_FieldPathValue {
	switch fp.selector {
	case ListProjectsResponse_FieldPathSelectorProjects:
		return &ListProjectsResponse_FieldTerminalPathValue{ListProjectsResponse_FieldTerminalPath: *fp, value: value.([]*project.Project)}
	case ListProjectsResponse_FieldPathSelectorPrevPageToken:
		return &ListProjectsResponse_FieldTerminalPathValue{ListProjectsResponse_FieldTerminalPath: *fp, value: value.(*project.PagerCursor)}
	case ListProjectsResponse_FieldPathSelectorNextPageToken:
		return &ListProjectsResponse_FieldTerminalPathValue{ListProjectsResponse_FieldTerminalPath: *fp, value: value.(*project.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fp.selector))
	}
}

func (fp *ListProjectsResponse_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ListProjectsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListProjectsResponse_FieldPathArrayOfValues {
	fpaov := &ListProjectsResponse_FieldTerminalPathArrayOfValues{ListProjectsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListProjectsResponse_FieldPathSelectorProjects:
		return &ListProjectsResponse_FieldTerminalPathArrayOfValues{ListProjectsResponse_FieldTerminalPath: *fp, values: values.([][]*project.Project)}
	case ListProjectsResponse_FieldPathSelectorPrevPageToken:
		return &ListProjectsResponse_FieldTerminalPathArrayOfValues{ListProjectsResponse_FieldTerminalPath: *fp, values: values.([]*project.PagerCursor)}
	case ListProjectsResponse_FieldPathSelectorNextPageToken:
		return &ListProjectsResponse_FieldTerminalPathArrayOfValues{ListProjectsResponse_FieldTerminalPath: *fp, values: values.([]*project.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fp.selector))
	}
	return fpaov
}

func (fp *ListProjectsResponse_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ListProjectsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListProjectsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case ListProjectsResponse_FieldPathSelectorProjects:
		return &ListProjectsResponse_FieldTerminalPathArrayItemValue{ListProjectsResponse_FieldTerminalPath: *fp, value: value.(*project.Project)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fp.selector))
	}
}

func (fp *ListProjectsResponse_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type ListProjectsResponse_FieldSubPath struct {
	selector ListProjectsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListProjectsResponse_FieldPath = (*ListProjectsResponse_FieldSubPath)(nil)

func (fps *ListProjectsResponse_FieldSubPath) Selector() ListProjectsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ListProjectsResponse_FieldSubPath) AsProjectsSubPath() (project.Project_FieldPath, bool) {
	res, ok := fps.subPath.(project.Project_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *ListProjectsResponse_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *ListProjectsResponse_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source ListProjectsResponse
func (fps *ListProjectsResponse_FieldSubPath) Get(source *ListProjectsResponse) (values []interface{}) {
	if asProjectFieldPath, ok := fps.AsProjectsSubPath(); ok {
		for _, item := range source.GetProjects() {
			values = append(values, asProjectFieldPath.Get(item)...)
		}
	} else {
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fps.selector))
	}
	return
}

func (fps *ListProjectsResponse_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*ListProjectsResponse))
}

// GetSingle returns value of selected field from source ListProjectsResponse
func (fps *ListProjectsResponse_FieldSubPath) GetSingle(source *ListProjectsResponse) (interface{}, bool) {
	switch fps.selector {
	case ListProjectsResponse_FieldPathSelectorProjects:
		if len(source.GetProjects()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetProjects()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fps.selector))
	}
}

func (fps *ListProjectsResponse_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*ListProjectsResponse))
}

// GetDefault returns a default value of the field type
func (fps *ListProjectsResponse_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *ListProjectsResponse_FieldSubPath) ClearValue(item *ListProjectsResponse) {
	if item != nil {
		switch fps.selector {
		case ListProjectsResponse_FieldPathSelectorProjects:
			for _, subItem := range item.Projects {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fps.selector))
		}
	}
}

func (fps *ListProjectsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListProjectsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fps *ListProjectsResponse_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *ListProjectsResponse_FieldSubPath) WithIValue(value interface{}) ListProjectsResponse_FieldPathValue {
	return &ListProjectsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *ListProjectsResponse_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *ListProjectsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ListProjectsResponse_FieldPathArrayOfValues {
	return &ListProjectsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *ListProjectsResponse_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *ListProjectsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ListProjectsResponse_FieldPathArrayItemValue {
	return &ListProjectsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *ListProjectsResponse_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// ListProjectsResponse_FieldPathValue allows storing values for ListProjectsResponse fields according to their type
type ListProjectsResponse_FieldPathValue interface {
	ListProjectsResponse_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ListProjectsResponse)
	CompareWith(*ListProjectsResponse) (cmp int, comparable bool)
}

func ParseListProjectsResponse_FieldPathValue(pathStr, valueStr string) (ListProjectsResponse_FieldPathValue, error) {
	fp, err := ParseListProjectsResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ListProjectsResponse field path value from %s: %v", valueStr, err)
	}
	return fpv.(ListProjectsResponse_FieldPathValue), nil
}

func MustParseListProjectsResponse_FieldPathValue(pathStr, valueStr string) ListProjectsResponse_FieldPathValue {
	fpv, err := ParseListProjectsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListProjectsResponse_FieldTerminalPathValue struct {
	ListProjectsResponse_FieldTerminalPath
	value interface{}
}

var _ ListProjectsResponse_FieldPathValue = (*ListProjectsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListProjectsResponse' as interface{}
func (fpv *ListProjectsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListProjectsResponse_FieldTerminalPathValue) AsProjectsValue() ([]*project.Project, bool) {
	res, ok := fpv.value.([]*project.Project)
	return res, ok
}
func (fpv *ListProjectsResponse_FieldTerminalPathValue) AsPrevPageTokenValue() (*project.PagerCursor, bool) {
	res, ok := fpv.value.(*project.PagerCursor)
	return res, ok
}
func (fpv *ListProjectsResponse_FieldTerminalPathValue) AsNextPageTokenValue() (*project.PagerCursor, bool) {
	res, ok := fpv.value.(*project.PagerCursor)
	return res, ok
}

// SetTo stores value for selected field for object ListProjectsResponse
func (fpv *ListProjectsResponse_FieldTerminalPathValue) SetTo(target **ListProjectsResponse) {
	if *target == nil {
		*target = new(ListProjectsResponse)
	}
	switch fpv.selector {
	case ListProjectsResponse_FieldPathSelectorProjects:
		(*target).Projects = fpv.value.([]*project.Project)
	case ListProjectsResponse_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*project.PagerCursor)
	case ListProjectsResponse_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*project.PagerCursor)
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fpv.selector))
	}
}

func (fpv *ListProjectsResponse_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ListProjectsResponse)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ListProjectsResponse_FieldTerminalPathValue' with the value under path in 'ListProjectsResponse'.
func (fpv *ListProjectsResponse_FieldTerminalPathValue) CompareWith(source *ListProjectsResponse) (int, bool) {
	switch fpv.selector {
	case ListProjectsResponse_FieldPathSelectorProjects:
		return 0, false
	case ListProjectsResponse_FieldPathSelectorPrevPageToken:
		return 0, false
	case ListProjectsResponse_FieldPathSelectorNextPageToken:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fpv.selector))
	}
}

func (fpv *ListProjectsResponse_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ListProjectsResponse))
}

type ListProjectsResponse_FieldSubPathValue struct {
	ListProjectsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListProjectsResponse_FieldPathValue = (*ListProjectsResponse_FieldSubPathValue)(nil)

func (fpvs *ListProjectsResponse_FieldSubPathValue) AsProjectsPathValue() (project.Project_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(project.Project_FieldPathValue)
	return res, ok
}

func (fpvs *ListProjectsResponse_FieldSubPathValue) SetTo(target **ListProjectsResponse) {
	if *target == nil {
		*target = new(ListProjectsResponse)
	}
	switch fpvs.Selector() {
	case ListProjectsResponse_FieldPathSelectorProjects:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fpvs.Selector()))
	}
}

func (fpvs *ListProjectsResponse_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ListProjectsResponse)
	fpvs.SetTo(&typedObject)
}

func (fpvs *ListProjectsResponse_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *ListProjectsResponse_FieldSubPathValue) CompareWith(source *ListProjectsResponse) (int, bool) {
	switch fpvs.Selector() {
	case ListProjectsResponse_FieldPathSelectorProjects:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fpvs.Selector()))
	}
}

func (fpvs *ListProjectsResponse_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*ListProjectsResponse))
}

// ListProjectsResponse_FieldPathArrayItemValue allows storing single item in Path-specific values for ListProjectsResponse according to their type
// Present only for array (repeated) types.
type ListProjectsResponse_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ListProjectsResponse_FieldPath
	ContainsValue(*ListProjectsResponse) bool
}

// ParseListProjectsResponse_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseListProjectsResponse_FieldPathArrayItemValue(pathStr, valueStr string) (ListProjectsResponse_FieldPathArrayItemValue, error) {
	fp, err := ParseListProjectsResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ListProjectsResponse field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ListProjectsResponse_FieldPathArrayItemValue), nil
}

func MustParseListProjectsResponse_FieldPathArrayItemValue(pathStr, valueStr string) ListProjectsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseListProjectsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListProjectsResponse_FieldTerminalPathArrayItemValue struct {
	ListProjectsResponse_FieldTerminalPath
	value interface{}
}

var _ ListProjectsResponse_FieldPathArrayItemValue = (*ListProjectsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListProjectsResponse as interface{}
func (fpaiv *ListProjectsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ListProjectsResponse_FieldTerminalPathArrayItemValue) AsProjectsItemValue() (*project.Project, bool) {
	res, ok := fpaiv.value.(*project.Project)
	return res, ok
}

func (fpaiv *ListProjectsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ListProjectsResponse) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ListProjectsResponse_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ListProjectsResponse))
}

// Contains returns a boolean indicating if value that is being held is present in given 'ListProjectsResponse'
func (fpaiv *ListProjectsResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *ListProjectsResponse) bool {
	slice := fpaiv.ListProjectsResponse_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type ListProjectsResponse_FieldSubPathArrayItemValue struct {
	ListProjectsResponse_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ListProjectsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListProjectsResponse_FieldSubPathArrayItemValue) AsProjectsPathItemValue() (project.Project_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(project.Project_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ListProjectsResponse'
func (fpaivs *ListProjectsResponse_FieldSubPathArrayItemValue) ContainsValue(source *ListProjectsResponse) bool {
	switch fpaivs.Selector() {
	case ListProjectsResponse_FieldPathSelectorProjects:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for ListProjectsResponse: %d", fpaivs.Selector()))
	}
}

// ListProjectsResponse_FieldPathArrayOfValues allows storing slice of values for ListProjectsResponse fields according to their type
type ListProjectsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListProjectsResponse_FieldPath
}

func ParseListProjectsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) (ListProjectsResponse_FieldPathArrayOfValues, error) {
	fp, err := ParseListProjectsResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ListProjectsResponse field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ListProjectsResponse_FieldPathArrayOfValues), nil
}

func MustParseListProjectsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ListProjectsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseListProjectsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListProjectsResponse_FieldTerminalPathArrayOfValues struct {
	ListProjectsResponse_FieldTerminalPath
	values interface{}
}

var _ ListProjectsResponse_FieldPathArrayOfValues = (*ListProjectsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListProjectsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListProjectsResponse_FieldPathSelectorProjects:
		for _, v := range fpaov.values.([][]*project.Project) {
			values = append(values, v)
		}
	case ListProjectsResponse_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*project.PagerCursor) {
			values = append(values, v)
		}
	case ListProjectsResponse_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*project.PagerCursor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListProjectsResponse_FieldTerminalPathArrayOfValues) AsProjectsArrayOfValues() ([][]*project.Project, bool) {
	res, ok := fpaov.values.([][]*project.Project)
	return res, ok
}
func (fpaov *ListProjectsResponse_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*project.PagerCursor, bool) {
	res, ok := fpaov.values.([]*project.PagerCursor)
	return res, ok
}
func (fpaov *ListProjectsResponse_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*project.PagerCursor, bool) {
	res, ok := fpaov.values.([]*project.PagerCursor)
	return res, ok
}

type ListProjectsResponse_FieldSubPathArrayOfValues struct {
	ListProjectsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListProjectsResponse_FieldPathArrayOfValues = (*ListProjectsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListProjectsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListProjectsResponse_FieldSubPathArrayOfValues) AsProjectsPathArrayOfValues() (project.Project_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(project.Project_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type WatchProjectRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchProjectRequest_FieldPathSelector
	Get(source *WatchProjectRequest) []interface{}
	GetSingle(source *WatchProjectRequest) (interface{}, bool)
	ClearValue(item *WatchProjectRequest)

	// Those methods build corresponding WatchProjectRequest_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) WatchProjectRequest_FieldPathValue
	WithIArrayOfValues(values interface{}) WatchProjectRequest_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) WatchProjectRequest_FieldPathArrayItemValue
}

type WatchProjectRequest_FieldPathSelector int32

const (
	WatchProjectRequest_FieldPathSelectorName      WatchProjectRequest_FieldPathSelector = 0
	WatchProjectRequest_FieldPathSelectorFieldMask WatchProjectRequest_FieldPathSelector = 1
	WatchProjectRequest_FieldPathSelectorView      WatchProjectRequest_FieldPathSelector = 2
)

func (s WatchProjectRequest_FieldPathSelector) String() string {
	switch s {
	case WatchProjectRequest_FieldPathSelectorName:
		return "name"
	case WatchProjectRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchProjectRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", s))
	}
}

func BuildWatchProjectRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchProjectRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchProjectRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &WatchProjectRequest_FieldTerminalPath{selector: WatchProjectRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchProjectRequest_FieldTerminalPath{selector: WatchProjectRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchProjectRequest_FieldTerminalPath{selector: WatchProjectRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchProjectRequest", fp)
}

func ParseWatchProjectRequest_FieldPath(rawField string) (WatchProjectRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchProjectRequest_FieldPath(fp)
}

func MustParseWatchProjectRequest_FieldPath(rawField string) WatchProjectRequest_FieldPath {
	fp, err := ParseWatchProjectRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchProjectRequest_FieldTerminalPath struct {
	selector WatchProjectRequest_FieldPathSelector
}

var _ WatchProjectRequest_FieldPath = (*WatchProjectRequest_FieldTerminalPath)(nil)

func (fp *WatchProjectRequest_FieldTerminalPath) Selector() WatchProjectRequest_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *WatchProjectRequest_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *WatchProjectRequest_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source WatchProjectRequest
func (fp *WatchProjectRequest_FieldTerminalPath) Get(source *WatchProjectRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchProjectRequest_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case WatchProjectRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchProjectRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", fp.selector))
		}
	}
	return
}

func (fp *WatchProjectRequest_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*WatchProjectRequest))
}

// GetSingle returns value pointed by specific field of from source WatchProjectRequest
func (fp *WatchProjectRequest_FieldTerminalPath) GetSingle(source *WatchProjectRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchProjectRequest_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case WatchProjectRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchProjectRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", fp.selector))
	}
}

func (fp *WatchProjectRequest_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*WatchProjectRequest))
}

// GetDefault returns a default value of the field type
func (fp *WatchProjectRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchProjectRequest_FieldPathSelectorName:
		return (*project.Reference)(nil)
	case WatchProjectRequest_FieldPathSelectorFieldMask:
		return (*project.Project_FieldMask)(nil)
	case WatchProjectRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", fp.selector))
	}
}

func (fp *WatchProjectRequest_FieldTerminalPath) ClearValue(item *WatchProjectRequest) {
	if item != nil {
		switch fp.selector {
		case WatchProjectRequest_FieldPathSelectorName:
			item.Name = nil
		case WatchProjectRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchProjectRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchProjectRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchProjectRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchProjectRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchProjectRequest_FieldPathSelectorName ||
		fp.selector == WatchProjectRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchProjectRequest_FieldPathSelectorView
}

func (fp *WatchProjectRequest_FieldTerminalPath) WithIValue(value interface{}) WatchProjectRequest_FieldPathValue {
	switch fp.selector {
	case WatchProjectRequest_FieldPathSelectorName:
		return &WatchProjectRequest_FieldTerminalPathValue{WatchProjectRequest_FieldTerminalPath: *fp, value: value.(*project.Reference)}
	case WatchProjectRequest_FieldPathSelectorFieldMask:
		return &WatchProjectRequest_FieldTerminalPathValue{WatchProjectRequest_FieldTerminalPath: *fp, value: value.(*project.Project_FieldMask)}
	case WatchProjectRequest_FieldPathSelectorView:
		return &WatchProjectRequest_FieldTerminalPathValue{WatchProjectRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", fp.selector))
	}
}

func (fp *WatchProjectRequest_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *WatchProjectRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchProjectRequest_FieldPathArrayOfValues {
	fpaov := &WatchProjectRequest_FieldTerminalPathArrayOfValues{WatchProjectRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchProjectRequest_FieldPathSelectorName:
		return &WatchProjectRequest_FieldTerminalPathArrayOfValues{WatchProjectRequest_FieldTerminalPath: *fp, values: values.([]*project.Reference)}
	case WatchProjectRequest_FieldPathSelectorFieldMask:
		return &WatchProjectRequest_FieldTerminalPathArrayOfValues{WatchProjectRequest_FieldTerminalPath: *fp, values: values.([]*project.Project_FieldMask)}
	case WatchProjectRequest_FieldPathSelectorView:
		return &WatchProjectRequest_FieldTerminalPathArrayOfValues{WatchProjectRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", fp.selector))
	}
	return fpaov
}

func (fp *WatchProjectRequest_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *WatchProjectRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchProjectRequest_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", fp.selector))
	}
}

func (fp *WatchProjectRequest_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// WatchProjectRequest_FieldPathValue allows storing values for WatchProjectRequest fields according to their type
type WatchProjectRequest_FieldPathValue interface {
	WatchProjectRequest_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **WatchProjectRequest)
	CompareWith(*WatchProjectRequest) (cmp int, comparable bool)
}

func ParseWatchProjectRequest_FieldPathValue(pathStr, valueStr string) (WatchProjectRequest_FieldPathValue, error) {
	fp, err := ParseWatchProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(WatchProjectRequest_FieldPathValue), nil
}

func MustParseWatchProjectRequest_FieldPathValue(pathStr, valueStr string) WatchProjectRequest_FieldPathValue {
	fpv, err := ParseWatchProjectRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchProjectRequest_FieldTerminalPathValue struct {
	WatchProjectRequest_FieldTerminalPath
	value interface{}
}

var _ WatchProjectRequest_FieldPathValue = (*WatchProjectRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchProjectRequest' as interface{}
func (fpv *WatchProjectRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchProjectRequest_FieldTerminalPathValue) AsNameValue() (*project.Reference, bool) {
	res, ok := fpv.value.(*project.Reference)
	return res, ok
}
func (fpv *WatchProjectRequest_FieldTerminalPathValue) AsFieldMaskValue() (*project.Project_FieldMask, bool) {
	res, ok := fpv.value.(*project.Project_FieldMask)
	return res, ok
}
func (fpv *WatchProjectRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object WatchProjectRequest
func (fpv *WatchProjectRequest_FieldTerminalPathValue) SetTo(target **WatchProjectRequest) {
	if *target == nil {
		*target = new(WatchProjectRequest)
	}
	switch fpv.selector {
	case WatchProjectRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*project.Reference)
	case WatchProjectRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*project.Project_FieldMask)
	case WatchProjectRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", fpv.selector))
	}
}

func (fpv *WatchProjectRequest_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*WatchProjectRequest)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'WatchProjectRequest_FieldTerminalPathValue' with the value under path in 'WatchProjectRequest'.
func (fpv *WatchProjectRequest_FieldTerminalPathValue) CompareWith(source *WatchProjectRequest) (int, bool) {
	switch fpv.selector {
	case WatchProjectRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*project.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case WatchProjectRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchProjectRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectRequest: %d", fpv.selector))
	}
}

func (fpv *WatchProjectRequest_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*WatchProjectRequest))
}

// WatchProjectRequest_FieldPathArrayItemValue allows storing single item in Path-specific values for WatchProjectRequest according to their type
// Present only for array (repeated) types.
type WatchProjectRequest_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	WatchProjectRequest_FieldPath
	ContainsValue(*WatchProjectRequest) bool
}

// ParseWatchProjectRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) (WatchProjectRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(WatchProjectRequest_FieldPathArrayItemValue), nil
}

func MustParseWatchProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchProjectRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchProjectRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchProjectRequest_FieldTerminalPathArrayItemValue struct {
	WatchProjectRequest_FieldTerminalPath
	value interface{}
}

var _ WatchProjectRequest_FieldPathArrayItemValue = (*WatchProjectRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchProjectRequest as interface{}
func (fpaiv *WatchProjectRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *WatchProjectRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchProjectRequest) (interface{}, bool) {
	return nil, false
}

func (fpaiv *WatchProjectRequest_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*WatchProjectRequest))
}

// Contains returns a boolean indicating if value that is being held is present in given 'WatchProjectRequest'
func (fpaiv *WatchProjectRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchProjectRequest) bool {
	slice := fpaiv.WatchProjectRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// WatchProjectRequest_FieldPathArrayOfValues allows storing slice of values for WatchProjectRequest fields according to their type
type WatchProjectRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchProjectRequest_FieldPath
}

func ParseWatchProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchProjectRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(WatchProjectRequest_FieldPathArrayOfValues), nil
}

func MustParseWatchProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchProjectRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchProjectRequest_FieldTerminalPathArrayOfValues struct {
	WatchProjectRequest_FieldTerminalPath
	values interface{}
}

var _ WatchProjectRequest_FieldPathArrayOfValues = (*WatchProjectRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchProjectRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchProjectRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*project.Reference) {
			values = append(values, v)
		}
	case WatchProjectRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*project.Project_FieldMask) {
			values = append(values, v)
		}
	case WatchProjectRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchProjectRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*project.Reference, bool) {
	res, ok := fpaov.values.([]*project.Reference)
	return res, ok
}
func (fpaov *WatchProjectRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*project.Project_FieldMask, bool) {
	res, ok := fpaov.values.([]*project.Project_FieldMask)
	return res, ok
}
func (fpaov *WatchProjectRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type WatchProjectResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchProjectResponse_FieldPathSelector
	Get(source *WatchProjectResponse) []interface{}
	GetSingle(source *WatchProjectResponse) (interface{}, bool)
	ClearValue(item *WatchProjectResponse)

	// Those methods build corresponding WatchProjectResponse_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) WatchProjectResponse_FieldPathValue
	WithIArrayOfValues(values interface{}) WatchProjectResponse_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) WatchProjectResponse_FieldPathArrayItemValue
}

type WatchProjectResponse_FieldPathSelector int32

const (
	WatchProjectResponse_FieldPathSelectorChange WatchProjectResponse_FieldPathSelector = 0
)

func (s WatchProjectResponse_FieldPathSelector) String() string {
	switch s {
	case WatchProjectResponse_FieldPathSelectorChange:
		return "change"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", s))
	}
}

func BuildWatchProjectResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchProjectResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchProjectResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "change":
			return &WatchProjectResponse_FieldTerminalPath{selector: WatchProjectResponse_FieldPathSelectorChange}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchProjectResponse", fp)
}

func ParseWatchProjectResponse_FieldPath(rawField string) (WatchProjectResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchProjectResponse_FieldPath(fp)
}

func MustParseWatchProjectResponse_FieldPath(rawField string) WatchProjectResponse_FieldPath {
	fp, err := ParseWatchProjectResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchProjectResponse_FieldTerminalPath struct {
	selector WatchProjectResponse_FieldPathSelector
}

var _ WatchProjectResponse_FieldPath = (*WatchProjectResponse_FieldTerminalPath)(nil)

func (fp *WatchProjectResponse_FieldTerminalPath) Selector() WatchProjectResponse_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *WatchProjectResponse_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *WatchProjectResponse_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source WatchProjectResponse
func (fp *WatchProjectResponse_FieldTerminalPath) Get(source *WatchProjectResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchProjectResponse_FieldPathSelectorChange:
			if source.Change != nil {
				values = append(values, source.Change)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", fp.selector))
		}
	}
	return
}

func (fp *WatchProjectResponse_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*WatchProjectResponse))
}

// GetSingle returns value pointed by specific field of from source WatchProjectResponse
func (fp *WatchProjectResponse_FieldTerminalPath) GetSingle(source *WatchProjectResponse) (interface{}, bool) {
	switch fp.selector {
	case WatchProjectResponse_FieldPathSelectorChange:
		res := source.GetChange()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", fp.selector))
	}
}

func (fp *WatchProjectResponse_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*WatchProjectResponse))
}

// GetDefault returns a default value of the field type
func (fp *WatchProjectResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchProjectResponse_FieldPathSelectorChange:
		return (*project.ProjectChange)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", fp.selector))
	}
}

func (fp *WatchProjectResponse_FieldTerminalPath) ClearValue(item *WatchProjectResponse) {
	if item != nil {
		switch fp.selector {
		case WatchProjectResponse_FieldPathSelectorChange:
			item.Change = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchProjectResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchProjectResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchProjectResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchProjectResponse_FieldPathSelectorChange
}

func (fp *WatchProjectResponse_FieldTerminalPath) WithIValue(value interface{}) WatchProjectResponse_FieldPathValue {
	switch fp.selector {
	case WatchProjectResponse_FieldPathSelectorChange:
		return &WatchProjectResponse_FieldTerminalPathValue{WatchProjectResponse_FieldTerminalPath: *fp, value: value.(*project.ProjectChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", fp.selector))
	}
}

func (fp *WatchProjectResponse_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *WatchProjectResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchProjectResponse_FieldPathArrayOfValues {
	fpaov := &WatchProjectResponse_FieldTerminalPathArrayOfValues{WatchProjectResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchProjectResponse_FieldPathSelectorChange:
		return &WatchProjectResponse_FieldTerminalPathArrayOfValues{WatchProjectResponse_FieldTerminalPath: *fp, values: values.([]*project.ProjectChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", fp.selector))
	}
	return fpaov
}

func (fp *WatchProjectResponse_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *WatchProjectResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchProjectResponse_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", fp.selector))
	}
}

func (fp *WatchProjectResponse_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// WatchProjectResponse_FieldPathValue allows storing values for WatchProjectResponse fields according to their type
type WatchProjectResponse_FieldPathValue interface {
	WatchProjectResponse_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **WatchProjectResponse)
	CompareWith(*WatchProjectResponse) (cmp int, comparable bool)
}

func ParseWatchProjectResponse_FieldPathValue(pathStr, valueStr string) (WatchProjectResponse_FieldPathValue, error) {
	fp, err := ParseWatchProjectResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectResponse field path value from %s: %v", valueStr, err)
	}
	return fpv.(WatchProjectResponse_FieldPathValue), nil
}

func MustParseWatchProjectResponse_FieldPathValue(pathStr, valueStr string) WatchProjectResponse_FieldPathValue {
	fpv, err := ParseWatchProjectResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchProjectResponse_FieldTerminalPathValue struct {
	WatchProjectResponse_FieldTerminalPath
	value interface{}
}

var _ WatchProjectResponse_FieldPathValue = (*WatchProjectResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchProjectResponse' as interface{}
func (fpv *WatchProjectResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchProjectResponse_FieldTerminalPathValue) AsChangeValue() (*project.ProjectChange, bool) {
	res, ok := fpv.value.(*project.ProjectChange)
	return res, ok
}

// SetTo stores value for selected field for object WatchProjectResponse
func (fpv *WatchProjectResponse_FieldTerminalPathValue) SetTo(target **WatchProjectResponse) {
	if *target == nil {
		*target = new(WatchProjectResponse)
	}
	switch fpv.selector {
	case WatchProjectResponse_FieldPathSelectorChange:
		(*target).Change = fpv.value.(*project.ProjectChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", fpv.selector))
	}
}

func (fpv *WatchProjectResponse_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*WatchProjectResponse)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'WatchProjectResponse_FieldTerminalPathValue' with the value under path in 'WatchProjectResponse'.
func (fpv *WatchProjectResponse_FieldTerminalPathValue) CompareWith(source *WatchProjectResponse) (int, bool) {
	switch fpv.selector {
	case WatchProjectResponse_FieldPathSelectorChange:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectResponse: %d", fpv.selector))
	}
}

func (fpv *WatchProjectResponse_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*WatchProjectResponse))
}

// WatchProjectResponse_FieldPathArrayItemValue allows storing single item in Path-specific values for WatchProjectResponse according to their type
// Present only for array (repeated) types.
type WatchProjectResponse_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	WatchProjectResponse_FieldPath
	ContainsValue(*WatchProjectResponse) bool
}

// ParseWatchProjectResponse_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchProjectResponse_FieldPathArrayItemValue(pathStr, valueStr string) (WatchProjectResponse_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchProjectResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectResponse field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(WatchProjectResponse_FieldPathArrayItemValue), nil
}

func MustParseWatchProjectResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchProjectResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchProjectResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchProjectResponse_FieldTerminalPathArrayItemValue struct {
	WatchProjectResponse_FieldTerminalPath
	value interface{}
}

var _ WatchProjectResponse_FieldPathArrayItemValue = (*WatchProjectResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchProjectResponse as interface{}
func (fpaiv *WatchProjectResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *WatchProjectResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchProjectResponse) (interface{}, bool) {
	return nil, false
}

func (fpaiv *WatchProjectResponse_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*WatchProjectResponse))
}

// Contains returns a boolean indicating if value that is being held is present in given 'WatchProjectResponse'
func (fpaiv *WatchProjectResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchProjectResponse) bool {
	slice := fpaiv.WatchProjectResponse_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// WatchProjectResponse_FieldPathArrayOfValues allows storing slice of values for WatchProjectResponse fields according to their type
type WatchProjectResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchProjectResponse_FieldPath
}

func ParseWatchProjectResponse_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchProjectResponse_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchProjectResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectResponse field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(WatchProjectResponse_FieldPathArrayOfValues), nil
}

func MustParseWatchProjectResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchProjectResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchProjectResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchProjectResponse_FieldTerminalPathArrayOfValues struct {
	WatchProjectResponse_FieldTerminalPath
	values interface{}
}

var _ WatchProjectResponse_FieldPathArrayOfValues = (*WatchProjectResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchProjectResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchProjectResponse_FieldPathSelectorChange:
		for _, v := range fpaov.values.([]*project.ProjectChange) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchProjectResponse_FieldTerminalPathArrayOfValues) AsChangeArrayOfValues() ([]*project.ProjectChange, bool) {
	res, ok := fpaov.values.([]*project.ProjectChange)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type WatchProjectsRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchProjectsRequest_FieldPathSelector
	Get(source *WatchProjectsRequest) []interface{}
	GetSingle(source *WatchProjectsRequest) (interface{}, bool)
	ClearValue(item *WatchProjectsRequest)

	// Those methods build corresponding WatchProjectsRequest_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) WatchProjectsRequest_FieldPathValue
	WithIArrayOfValues(values interface{}) WatchProjectsRequest_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) WatchProjectsRequest_FieldPathArrayItemValue
}

type WatchProjectsRequest_FieldPathSelector int32

const (
	WatchProjectsRequest_FieldPathSelectorType         WatchProjectsRequest_FieldPathSelector = 0
	WatchProjectsRequest_FieldPathSelectorPageSize     WatchProjectsRequest_FieldPathSelector = 1
	WatchProjectsRequest_FieldPathSelectorPageToken    WatchProjectsRequest_FieldPathSelector = 2
	WatchProjectsRequest_FieldPathSelectorOrderBy      WatchProjectsRequest_FieldPathSelector = 3
	WatchProjectsRequest_FieldPathSelectorResumeToken  WatchProjectsRequest_FieldPathSelector = 4
	WatchProjectsRequest_FieldPathSelectorFilter       WatchProjectsRequest_FieldPathSelector = 5
	WatchProjectsRequest_FieldPathSelectorFieldMask    WatchProjectsRequest_FieldPathSelector = 6
	WatchProjectsRequest_FieldPathSelectorView         WatchProjectsRequest_FieldPathSelector = 7
	WatchProjectsRequest_FieldPathSelectorMaxChunkSize WatchProjectsRequest_FieldPathSelector = 8
)

func (s WatchProjectsRequest_FieldPathSelector) String() string {
	switch s {
	case WatchProjectsRequest_FieldPathSelectorType:
		return "type"
	case WatchProjectsRequest_FieldPathSelectorPageSize:
		return "page_size"
	case WatchProjectsRequest_FieldPathSelectorPageToken:
		return "page_token"
	case WatchProjectsRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case WatchProjectsRequest_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchProjectsRequest_FieldPathSelectorFilter:
		return "filter"
	case WatchProjectsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchProjectsRequest_FieldPathSelectorView:
		return "view"
	case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
		return "max_chunk_size"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", s))
	}
}

func BuildWatchProjectsRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchProjectsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchProjectsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &WatchProjectsRequest_FieldTerminalPath{selector: WatchProjectsRequest_FieldPathSelectorType}, nil
		case "page_size", "pageSize", "page-size":
			return &WatchProjectsRequest_FieldTerminalPath{selector: WatchProjectsRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &WatchProjectsRequest_FieldTerminalPath{selector: WatchProjectsRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &WatchProjectsRequest_FieldTerminalPath{selector: WatchProjectsRequest_FieldPathSelectorOrderBy}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchProjectsRequest_FieldTerminalPath{selector: WatchProjectsRequest_FieldPathSelectorResumeToken}, nil
		case "filter":
			return &WatchProjectsRequest_FieldTerminalPath{selector: WatchProjectsRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchProjectsRequest_FieldTerminalPath{selector: WatchProjectsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchProjectsRequest_FieldTerminalPath{selector: WatchProjectsRequest_FieldPathSelectorView}, nil
		case "max_chunk_size", "maxChunkSize", "max-chunk-size":
			return &WatchProjectsRequest_FieldTerminalPath{selector: WatchProjectsRequest_FieldPathSelectorMaxChunkSize}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchProjectsRequest", fp)
}

func ParseWatchProjectsRequest_FieldPath(rawField string) (WatchProjectsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchProjectsRequest_FieldPath(fp)
}

func MustParseWatchProjectsRequest_FieldPath(rawField string) WatchProjectsRequest_FieldPath {
	fp, err := ParseWatchProjectsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchProjectsRequest_FieldTerminalPath struct {
	selector WatchProjectsRequest_FieldPathSelector
}

var _ WatchProjectsRequest_FieldPath = (*WatchProjectsRequest_FieldTerminalPath)(nil)

func (fp *WatchProjectsRequest_FieldTerminalPath) Selector() WatchProjectsRequest_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *WatchProjectsRequest_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *WatchProjectsRequest_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source WatchProjectsRequest
func (fp *WatchProjectsRequest_FieldTerminalPath) Get(source *WatchProjectsRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchProjectsRequest_FieldPathSelectorType:
			values = append(values, source.Type)
		case WatchProjectsRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case WatchProjectsRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case WatchProjectsRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case WatchProjectsRequest_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchProjectsRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case WatchProjectsRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchProjectsRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
			values = append(values, source.MaxChunkSize)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", fp.selector))
		}
	}
	return
}

func (fp *WatchProjectsRequest_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*WatchProjectsRequest))
}

// GetSingle returns value pointed by specific field of from source WatchProjectsRequest
func (fp *WatchProjectsRequest_FieldTerminalPath) GetSingle(source *WatchProjectsRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchProjectsRequest_FieldPathSelectorType:
		return source.GetType(), source != nil
	case WatchProjectsRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case WatchProjectsRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case WatchProjectsRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case WatchProjectsRequest_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchProjectsRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case WatchProjectsRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchProjectsRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
		return source.GetMaxChunkSize(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", fp.selector))
	}
}

func (fp *WatchProjectsRequest_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*WatchProjectsRequest))
}

// GetDefault returns a default value of the field type
func (fp *WatchProjectsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchProjectsRequest_FieldPathSelectorType:
		return watch_type.WatchType_STATEFUL
	case WatchProjectsRequest_FieldPathSelectorPageSize:
		return int32(0)
	case WatchProjectsRequest_FieldPathSelectorPageToken:
		return (*project.PagerCursor)(nil)
	case WatchProjectsRequest_FieldPathSelectorOrderBy:
		return (*project.OrderBy)(nil)
	case WatchProjectsRequest_FieldPathSelectorResumeToken:
		return ""
	case WatchProjectsRequest_FieldPathSelectorFilter:
		return (*project.Filter)(nil)
	case WatchProjectsRequest_FieldPathSelectorFieldMask:
		return (*project.Project_FieldMask)(nil)
	case WatchProjectsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", fp.selector))
	}
}

func (fp *WatchProjectsRequest_FieldTerminalPath) ClearValue(item *WatchProjectsRequest) {
	if item != nil {
		switch fp.selector {
		case WatchProjectsRequest_FieldPathSelectorType:
			item.Type = watch_type.WatchType_STATEFUL
		case WatchProjectsRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case WatchProjectsRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case WatchProjectsRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case WatchProjectsRequest_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchProjectsRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case WatchProjectsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchProjectsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
			item.MaxChunkSize = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchProjectsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchProjectsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchProjectsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchProjectsRequest_FieldPathSelectorType ||
		fp.selector == WatchProjectsRequest_FieldPathSelectorPageSize ||
		fp.selector == WatchProjectsRequest_FieldPathSelectorPageToken ||
		fp.selector == WatchProjectsRequest_FieldPathSelectorOrderBy ||
		fp.selector == WatchProjectsRequest_FieldPathSelectorResumeToken ||
		fp.selector == WatchProjectsRequest_FieldPathSelectorFilter ||
		fp.selector == WatchProjectsRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchProjectsRequest_FieldPathSelectorView ||
		fp.selector == WatchProjectsRequest_FieldPathSelectorMaxChunkSize
}

func (fp *WatchProjectsRequest_FieldTerminalPath) WithIValue(value interface{}) WatchProjectsRequest_FieldPathValue {
	switch fp.selector {
	case WatchProjectsRequest_FieldPathSelectorType:
		return &WatchProjectsRequest_FieldTerminalPathValue{WatchProjectsRequest_FieldTerminalPath: *fp, value: value.(watch_type.WatchType)}
	case WatchProjectsRequest_FieldPathSelectorPageSize:
		return &WatchProjectsRequest_FieldTerminalPathValue{WatchProjectsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case WatchProjectsRequest_FieldPathSelectorPageToken:
		return &WatchProjectsRequest_FieldTerminalPathValue{WatchProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.PagerCursor)}
	case WatchProjectsRequest_FieldPathSelectorOrderBy:
		return &WatchProjectsRequest_FieldTerminalPathValue{WatchProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.OrderBy)}
	case WatchProjectsRequest_FieldPathSelectorResumeToken:
		return &WatchProjectsRequest_FieldTerminalPathValue{WatchProjectsRequest_FieldTerminalPath: *fp, value: value.(string)}
	case WatchProjectsRequest_FieldPathSelectorFilter:
		return &WatchProjectsRequest_FieldTerminalPathValue{WatchProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.Filter)}
	case WatchProjectsRequest_FieldPathSelectorFieldMask:
		return &WatchProjectsRequest_FieldTerminalPathValue{WatchProjectsRequest_FieldTerminalPath: *fp, value: value.(*project.Project_FieldMask)}
	case WatchProjectsRequest_FieldPathSelectorView:
		return &WatchProjectsRequest_FieldTerminalPathValue{WatchProjectsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
		return &WatchProjectsRequest_FieldTerminalPathValue{WatchProjectsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", fp.selector))
	}
}

func (fp *WatchProjectsRequest_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *WatchProjectsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchProjectsRequest_FieldPathArrayOfValues {
	fpaov := &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchProjectsRequest_FieldPathSelectorType:
		return &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp, values: values.([]watch_type.WatchType)}
	case WatchProjectsRequest_FieldPathSelectorPageSize:
		return &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case WatchProjectsRequest_FieldPathSelectorPageToken:
		return &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp, values: values.([]*project.PagerCursor)}
	case WatchProjectsRequest_FieldPathSelectorOrderBy:
		return &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp, values: values.([]*project.OrderBy)}
	case WatchProjectsRequest_FieldPathSelectorResumeToken:
		return &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchProjectsRequest_FieldPathSelectorFilter:
		return &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp, values: values.([]*project.Filter)}
	case WatchProjectsRequest_FieldPathSelectorFieldMask:
		return &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp, values: values.([]*project.Project_FieldMask)}
	case WatchProjectsRequest_FieldPathSelectorView:
		return &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
		return &WatchProjectsRequest_FieldTerminalPathArrayOfValues{WatchProjectsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", fp.selector))
	}
	return fpaov
}

func (fp *WatchProjectsRequest_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *WatchProjectsRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchProjectsRequest_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", fp.selector))
	}
}

func (fp *WatchProjectsRequest_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// WatchProjectsRequest_FieldPathValue allows storing values for WatchProjectsRequest fields according to their type
type WatchProjectsRequest_FieldPathValue interface {
	WatchProjectsRequest_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **WatchProjectsRequest)
	CompareWith(*WatchProjectsRequest) (cmp int, comparable bool)
}

func ParseWatchProjectsRequest_FieldPathValue(pathStr, valueStr string) (WatchProjectsRequest_FieldPathValue, error) {
	fp, err := ParseWatchProjectsRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectsRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(WatchProjectsRequest_FieldPathValue), nil
}

func MustParseWatchProjectsRequest_FieldPathValue(pathStr, valueStr string) WatchProjectsRequest_FieldPathValue {
	fpv, err := ParseWatchProjectsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchProjectsRequest_FieldTerminalPathValue struct {
	WatchProjectsRequest_FieldTerminalPath
	value interface{}
}

var _ WatchProjectsRequest_FieldPathValue = (*WatchProjectsRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchProjectsRequest' as interface{}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) AsTypeValue() (watch_type.WatchType, bool) {
	res, ok := fpv.value.(watch_type.WatchType)
	return res, ok
}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) AsPageSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) AsPageTokenValue() (*project.PagerCursor, bool) {
	res, ok := fpv.value.(*project.PagerCursor)
	return res, ok
}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) AsOrderByValue() (*project.OrderBy, bool) {
	res, ok := fpv.value.(*project.OrderBy)
	return res, ok
}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) AsFilterValue() (*project.Filter, bool) {
	res, ok := fpv.value.(*project.Filter)
	return res, ok
}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) AsFieldMaskValue() (*project.Project_FieldMask, bool) {
	res, ok := fpv.value.(*project.Project_FieldMask)
	return res, ok
}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) AsMaxChunkSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object WatchProjectsRequest
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) SetTo(target **WatchProjectsRequest) {
	if *target == nil {
		*target = new(WatchProjectsRequest)
	}
	switch fpv.selector {
	case WatchProjectsRequest_FieldPathSelectorType:
		(*target).Type = fpv.value.(watch_type.WatchType)
	case WatchProjectsRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case WatchProjectsRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*project.PagerCursor)
	case WatchProjectsRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*project.OrderBy)
	case WatchProjectsRequest_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchProjectsRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*project.Filter)
	case WatchProjectsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*project.Project_FieldMask)
	case WatchProjectsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
		(*target).MaxChunkSize = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", fpv.selector))
	}
}

func (fpv *WatchProjectsRequest_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*WatchProjectsRequest)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'WatchProjectsRequest_FieldTerminalPathValue' with the value under path in 'WatchProjectsRequest'.
func (fpv *WatchProjectsRequest_FieldTerminalPathValue) CompareWith(source *WatchProjectsRequest) (int, bool) {
	switch fpv.selector {
	case WatchProjectsRequest_FieldPathSelectorType:
		leftValue := fpv.value.(watch_type.WatchType)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchProjectsRequest_FieldPathSelectorPageSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetPageSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchProjectsRequest_FieldPathSelectorPageToken:
		return 0, false
	case WatchProjectsRequest_FieldPathSelectorOrderBy:
		return 0, false
	case WatchProjectsRequest_FieldPathSelectorResumeToken:
		leftValue := fpv.value.(string)
		rightValue := source.GetResumeToken()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchProjectsRequest_FieldPathSelectorFilter:
		return 0, false
	case WatchProjectsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchProjectsRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetMaxChunkSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsRequest: %d", fpv.selector))
	}
}

func (fpv *WatchProjectsRequest_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*WatchProjectsRequest))
}

// WatchProjectsRequest_FieldPathArrayItemValue allows storing single item in Path-specific values for WatchProjectsRequest according to their type
// Present only for array (repeated) types.
type WatchProjectsRequest_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	WatchProjectsRequest_FieldPath
	ContainsValue(*WatchProjectsRequest) bool
}

// ParseWatchProjectsRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchProjectsRequest_FieldPathArrayItemValue(pathStr, valueStr string) (WatchProjectsRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchProjectsRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectsRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(WatchProjectsRequest_FieldPathArrayItemValue), nil
}

func MustParseWatchProjectsRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchProjectsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchProjectsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchProjectsRequest_FieldTerminalPathArrayItemValue struct {
	WatchProjectsRequest_FieldTerminalPath
	value interface{}
}

var _ WatchProjectsRequest_FieldPathArrayItemValue = (*WatchProjectsRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchProjectsRequest as interface{}
func (fpaiv *WatchProjectsRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *WatchProjectsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchProjectsRequest) (interface{}, bool) {
	return nil, false
}

func (fpaiv *WatchProjectsRequest_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*WatchProjectsRequest))
}

// Contains returns a boolean indicating if value that is being held is present in given 'WatchProjectsRequest'
func (fpaiv *WatchProjectsRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchProjectsRequest) bool {
	slice := fpaiv.WatchProjectsRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// WatchProjectsRequest_FieldPathArrayOfValues allows storing slice of values for WatchProjectsRequest fields according to their type
type WatchProjectsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchProjectsRequest_FieldPath
}

func ParseWatchProjectsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchProjectsRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchProjectsRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectsRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(WatchProjectsRequest_FieldPathArrayOfValues), nil
}

func MustParseWatchProjectsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchProjectsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchProjectsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchProjectsRequest_FieldTerminalPathArrayOfValues struct {
	WatchProjectsRequest_FieldTerminalPath
	values interface{}
}

var _ WatchProjectsRequest_FieldPathArrayOfValues = (*WatchProjectsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchProjectsRequest_FieldPathSelectorType:
		for _, v := range fpaov.values.([]watch_type.WatchType) {
			values = append(values, v)
		}
	case WatchProjectsRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case WatchProjectsRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*project.PagerCursor) {
			values = append(values, v)
		}
	case WatchProjectsRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*project.OrderBy) {
			values = append(values, v)
		}
	case WatchProjectsRequest_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchProjectsRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*project.Filter) {
			values = append(values, v)
		}
	case WatchProjectsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*project.Project_FieldMask) {
			values = append(values, v)
		}
	case WatchProjectsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case WatchProjectsRequest_FieldPathSelectorMaxChunkSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]watch_type.WatchType, bool) {
	res, ok := fpaov.values.([]watch_type.WatchType)
	return res, ok
}
func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*project.PagerCursor, bool) {
	res, ok := fpaov.values.([]*project.PagerCursor)
	return res, ok
}
func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*project.OrderBy, bool) {
	res, ok := fpaov.values.([]*project.OrderBy)
	return res, ok
}
func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*project.Filter, bool) {
	res, ok := fpaov.values.([]*project.Filter)
	return res, ok
}
func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*project.Project_FieldMask, bool) {
	res, ok := fpaov.values.([]*project.Project_FieldMask)
	return res, ok
}
func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *WatchProjectsRequest_FieldTerminalPathArrayOfValues) AsMaxChunkSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type WatchProjectsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchProjectsResponse_FieldPathSelector
	Get(source *WatchProjectsResponse) []interface{}
	GetSingle(source *WatchProjectsResponse) (interface{}, bool)
	ClearValue(item *WatchProjectsResponse)

	// Those methods build corresponding WatchProjectsResponse_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) WatchProjectsResponse_FieldPathValue
	WithIArrayOfValues(values interface{}) WatchProjectsResponse_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) WatchProjectsResponse_FieldPathArrayItemValue
}

type WatchProjectsResponse_FieldPathSelector int32

const (
	WatchProjectsResponse_FieldPathSelectorProjectChanges  WatchProjectsResponse_FieldPathSelector = 0
	WatchProjectsResponse_FieldPathSelectorIsCurrent       WatchProjectsResponse_FieldPathSelector = 1
	WatchProjectsResponse_FieldPathSelectorPageTokenChange WatchProjectsResponse_FieldPathSelector = 2
	WatchProjectsResponse_FieldPathSelectorResumeToken     WatchProjectsResponse_FieldPathSelector = 3
	WatchProjectsResponse_FieldPathSelectorSnapshotSize    WatchProjectsResponse_FieldPathSelector = 4
	WatchProjectsResponse_FieldPathSelectorIsSoftReset     WatchProjectsResponse_FieldPathSelector = 5
	WatchProjectsResponse_FieldPathSelectorIsHardReset     WatchProjectsResponse_FieldPathSelector = 6
)

func (s WatchProjectsResponse_FieldPathSelector) String() string {
	switch s {
	case WatchProjectsResponse_FieldPathSelectorProjectChanges:
		return "project_changes"
	case WatchProjectsResponse_FieldPathSelectorIsCurrent:
		return "is_current"
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		return "page_token_change"
	case WatchProjectsResponse_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
		return "snapshot_size"
	case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
		return "is_soft_reset"
	case WatchProjectsResponse_FieldPathSelectorIsHardReset:
		return "is_hard_reset"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", s))
	}
}

func BuildWatchProjectsResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchProjectsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchProjectsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "project_changes", "projectChanges", "project-changes":
			return &WatchProjectsResponse_FieldTerminalPath{selector: WatchProjectsResponse_FieldPathSelectorProjectChanges}, nil
		case "is_current", "isCurrent", "is-current":
			return &WatchProjectsResponse_FieldTerminalPath{selector: WatchProjectsResponse_FieldPathSelectorIsCurrent}, nil
		case "page_token_change", "pageTokenChange", "page-token-change":
			return &WatchProjectsResponse_FieldTerminalPath{selector: WatchProjectsResponse_FieldPathSelectorPageTokenChange}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchProjectsResponse_FieldTerminalPath{selector: WatchProjectsResponse_FieldPathSelectorResumeToken}, nil
		case "snapshot_size", "snapshotSize", "snapshot-size":
			return &WatchProjectsResponse_FieldTerminalPath{selector: WatchProjectsResponse_FieldPathSelectorSnapshotSize}, nil
		case "is_soft_reset", "isSoftReset", "is-soft-reset":
			return &WatchProjectsResponse_FieldTerminalPath{selector: WatchProjectsResponse_FieldPathSelectorIsSoftReset}, nil
		case "is_hard_reset", "isHardReset", "is-hard-reset":
			return &WatchProjectsResponse_FieldTerminalPath{selector: WatchProjectsResponse_FieldPathSelectorIsHardReset}, nil
		}
	} else {
		switch fp[0] {
		case "page_token_change", "pageTokenChange", "page-token-change":
			if subpath, err := BuildWatchProjectsResponsePageTokenChange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &WatchProjectsResponse_FieldSubPath{selector: WatchProjectsResponse_FieldPathSelectorPageTokenChange, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchProjectsResponse", fp)
}

func ParseWatchProjectsResponse_FieldPath(rawField string) (WatchProjectsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchProjectsResponse_FieldPath(fp)
}

func MustParseWatchProjectsResponse_FieldPath(rawField string) WatchProjectsResponse_FieldPath {
	fp, err := ParseWatchProjectsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchProjectsResponse_FieldTerminalPath struct {
	selector WatchProjectsResponse_FieldPathSelector
}

var _ WatchProjectsResponse_FieldPath = (*WatchProjectsResponse_FieldTerminalPath)(nil)

func (fp *WatchProjectsResponse_FieldTerminalPath) Selector() WatchProjectsResponse_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *WatchProjectsResponse_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *WatchProjectsResponse_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source WatchProjectsResponse
func (fp *WatchProjectsResponse_FieldTerminalPath) Get(source *WatchProjectsResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchProjectsResponse_FieldPathSelectorProjectChanges:
			for _, value := range source.GetProjectChanges() {
				values = append(values, value)
			}
		case WatchProjectsResponse_FieldPathSelectorIsCurrent:
			values = append(values, source.IsCurrent)
		case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
			if source.PageTokenChange != nil {
				values = append(values, source.PageTokenChange)
			}
		case WatchProjectsResponse_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
			values = append(values, source.SnapshotSize)
		case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
			values = append(values, source.IsSoftReset)
		case WatchProjectsResponse_FieldPathSelectorIsHardReset:
			values = append(values, source.IsHardReset)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fp.selector))
		}
	}
	return
}

func (fp *WatchProjectsResponse_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*WatchProjectsResponse))
}

// GetSingle returns value pointed by specific field of from source WatchProjectsResponse
func (fp *WatchProjectsResponse_FieldTerminalPath) GetSingle(source *WatchProjectsResponse) (interface{}, bool) {
	switch fp.selector {
	case WatchProjectsResponse_FieldPathSelectorProjectChanges:
		res := source.GetProjectChanges()
		return res, res != nil
	case WatchProjectsResponse_FieldPathSelectorIsCurrent:
		return source.GetIsCurrent(), source != nil
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		res := source.GetPageTokenChange()
		return res, res != nil
	case WatchProjectsResponse_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
		return source.GetSnapshotSize(), source != nil
	case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
		return source.GetIsSoftReset(), source != nil
	case WatchProjectsResponse_FieldPathSelectorIsHardReset:
		return source.GetIsHardReset(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fp.selector))
	}
}

func (fp *WatchProjectsResponse_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*WatchProjectsResponse))
}

// GetDefault returns a default value of the field type
func (fp *WatchProjectsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchProjectsResponse_FieldPathSelectorProjectChanges:
		return ([]*project.ProjectChange)(nil)
	case WatchProjectsResponse_FieldPathSelectorIsCurrent:
		return false
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		return (*WatchProjectsResponse_PageTokenChange)(nil)
	case WatchProjectsResponse_FieldPathSelectorResumeToken:
		return ""
	case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
		return int64(0)
	case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
		return false
	case WatchProjectsResponse_FieldPathSelectorIsHardReset:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fp.selector))
	}
}

func (fp *WatchProjectsResponse_FieldTerminalPath) ClearValue(item *WatchProjectsResponse) {
	if item != nil {
		switch fp.selector {
		case WatchProjectsResponse_FieldPathSelectorProjectChanges:
			item.ProjectChanges = nil
		case WatchProjectsResponse_FieldPathSelectorIsCurrent:
			item.IsCurrent = false
		case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
			item.PageTokenChange = nil
		case WatchProjectsResponse_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
			item.SnapshotSize = int64(0)
		case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
			item.IsSoftReset = false
		case WatchProjectsResponse_FieldPathSelectorIsHardReset:
			item.IsHardReset = false
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchProjectsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchProjectsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchProjectsResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchProjectsResponse_FieldPathSelectorProjectChanges ||
		fp.selector == WatchProjectsResponse_FieldPathSelectorIsCurrent ||
		fp.selector == WatchProjectsResponse_FieldPathSelectorResumeToken ||
		fp.selector == WatchProjectsResponse_FieldPathSelectorSnapshotSize ||
		fp.selector == WatchProjectsResponse_FieldPathSelectorIsSoftReset ||
		fp.selector == WatchProjectsResponse_FieldPathSelectorIsHardReset
}

func (fp *WatchProjectsResponse_FieldTerminalPath) WithIValue(value interface{}) WatchProjectsResponse_FieldPathValue {
	switch fp.selector {
	case WatchProjectsResponse_FieldPathSelectorProjectChanges:
		return &WatchProjectsResponse_FieldTerminalPathValue{WatchProjectsResponse_FieldTerminalPath: *fp, value: value.([]*project.ProjectChange)}
	case WatchProjectsResponse_FieldPathSelectorIsCurrent:
		return &WatchProjectsResponse_FieldTerminalPathValue{WatchProjectsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		return &WatchProjectsResponse_FieldTerminalPathValue{WatchProjectsResponse_FieldTerminalPath: *fp, value: value.(*WatchProjectsResponse_PageTokenChange)}
	case WatchProjectsResponse_FieldPathSelectorResumeToken:
		return &WatchProjectsResponse_FieldTerminalPathValue{WatchProjectsResponse_FieldTerminalPath: *fp, value: value.(string)}
	case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
		return &WatchProjectsResponse_FieldTerminalPathValue{WatchProjectsResponse_FieldTerminalPath: *fp, value: value.(int64)}
	case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
		return &WatchProjectsResponse_FieldTerminalPathValue{WatchProjectsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchProjectsResponse_FieldPathSelectorIsHardReset:
		return &WatchProjectsResponse_FieldTerminalPathValue{WatchProjectsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fp.selector))
	}
}

func (fp *WatchProjectsResponse_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *WatchProjectsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchProjectsResponse_FieldPathArrayOfValues {
	fpaov := &WatchProjectsResponse_FieldTerminalPathArrayOfValues{WatchProjectsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchProjectsResponse_FieldPathSelectorProjectChanges:
		return &WatchProjectsResponse_FieldTerminalPathArrayOfValues{WatchProjectsResponse_FieldTerminalPath: *fp, values: values.([][]*project.ProjectChange)}
	case WatchProjectsResponse_FieldPathSelectorIsCurrent:
		return &WatchProjectsResponse_FieldTerminalPathArrayOfValues{WatchProjectsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		return &WatchProjectsResponse_FieldTerminalPathArrayOfValues{WatchProjectsResponse_FieldTerminalPath: *fp, values: values.([]*WatchProjectsResponse_PageTokenChange)}
	case WatchProjectsResponse_FieldPathSelectorResumeToken:
		return &WatchProjectsResponse_FieldTerminalPathArrayOfValues{WatchProjectsResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
		return &WatchProjectsResponse_FieldTerminalPathArrayOfValues{WatchProjectsResponse_FieldTerminalPath: *fp, values: values.([]int64)}
	case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
		return &WatchProjectsResponse_FieldTerminalPathArrayOfValues{WatchProjectsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchProjectsResponse_FieldPathSelectorIsHardReset:
		return &WatchProjectsResponse_FieldTerminalPathArrayOfValues{WatchProjectsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fp.selector))
	}
	return fpaov
}

func (fp *WatchProjectsResponse_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *WatchProjectsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchProjectsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case WatchProjectsResponse_FieldPathSelectorProjectChanges:
		return &WatchProjectsResponse_FieldTerminalPathArrayItemValue{WatchProjectsResponse_FieldTerminalPath: *fp, value: value.(*project.ProjectChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fp.selector))
	}
}

func (fp *WatchProjectsResponse_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type WatchProjectsResponse_FieldSubPath struct {
	selector WatchProjectsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ WatchProjectsResponse_FieldPath = (*WatchProjectsResponse_FieldSubPath)(nil)

func (fps *WatchProjectsResponse_FieldSubPath) Selector() WatchProjectsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *WatchProjectsResponse_FieldSubPath) AsPageTokenChangeSubPath() (WatchProjectsResponsePageTokenChange_FieldPath, bool) {
	res, ok := fps.subPath.(WatchProjectsResponsePageTokenChange_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *WatchProjectsResponse_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *WatchProjectsResponse_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source WatchProjectsResponse
func (fps *WatchProjectsResponse_FieldSubPath) Get(source *WatchProjectsResponse) (values []interface{}) {
	if asPageTokenChangeFieldPath, ok := fps.AsPageTokenChangeSubPath(); ok {
		values = append(values, asPageTokenChangeFieldPath.Get(source.GetPageTokenChange())...)
	} else {
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fps.selector))
	}
	return
}

func (fps *WatchProjectsResponse_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*WatchProjectsResponse))
}

// GetSingle returns value of selected field from source WatchProjectsResponse
func (fps *WatchProjectsResponse_FieldSubPath) GetSingle(source *WatchProjectsResponse) (interface{}, bool) {
	switch fps.selector {
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		if source.GetPageTokenChange() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetPageTokenChange())
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fps.selector))
	}
}

func (fps *WatchProjectsResponse_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*WatchProjectsResponse))
}

// GetDefault returns a default value of the field type
func (fps *WatchProjectsResponse_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *WatchProjectsResponse_FieldSubPath) ClearValue(item *WatchProjectsResponse) {
	if item != nil {
		switch fps.selector {
		case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
			fps.subPath.ClearValueRaw(item.PageTokenChange)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fps.selector))
		}
	}
}

func (fps *WatchProjectsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*WatchProjectsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fps *WatchProjectsResponse_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *WatchProjectsResponse_FieldSubPath) WithIValue(value interface{}) WatchProjectsResponse_FieldPathValue {
	return &WatchProjectsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *WatchProjectsResponse_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *WatchProjectsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) WatchProjectsResponse_FieldPathArrayOfValues {
	return &WatchProjectsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *WatchProjectsResponse_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *WatchProjectsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) WatchProjectsResponse_FieldPathArrayItemValue {
	return &WatchProjectsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *WatchProjectsResponse_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// WatchProjectsResponse_FieldPathValue allows storing values for WatchProjectsResponse fields according to their type
type WatchProjectsResponse_FieldPathValue interface {
	WatchProjectsResponse_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **WatchProjectsResponse)
	CompareWith(*WatchProjectsResponse) (cmp int, comparable bool)
}

func ParseWatchProjectsResponse_FieldPathValue(pathStr, valueStr string) (WatchProjectsResponse_FieldPathValue, error) {
	fp, err := ParseWatchProjectsResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectsResponse field path value from %s: %v", valueStr, err)
	}
	return fpv.(WatchProjectsResponse_FieldPathValue), nil
}

func MustParseWatchProjectsResponse_FieldPathValue(pathStr, valueStr string) WatchProjectsResponse_FieldPathValue {
	fpv, err := ParseWatchProjectsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchProjectsResponse_FieldTerminalPathValue struct {
	WatchProjectsResponse_FieldTerminalPath
	value interface{}
}

var _ WatchProjectsResponse_FieldPathValue = (*WatchProjectsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchProjectsResponse' as interface{}
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) AsProjectChangesValue() ([]*project.ProjectChange, bool) {
	res, ok := fpv.value.([]*project.ProjectChange)
	return res, ok
}
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) AsIsCurrentValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) AsPageTokenChangeValue() (*WatchProjectsResponse_PageTokenChange, bool) {
	res, ok := fpv.value.(*WatchProjectsResponse_PageTokenChange)
	return res, ok
}
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) AsSnapshotSizeValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) AsIsSoftResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) AsIsHardResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object WatchProjectsResponse
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) SetTo(target **WatchProjectsResponse) {
	if *target == nil {
		*target = new(WatchProjectsResponse)
	}
	switch fpv.selector {
	case WatchProjectsResponse_FieldPathSelectorProjectChanges:
		(*target).ProjectChanges = fpv.value.([]*project.ProjectChange)
	case WatchProjectsResponse_FieldPathSelectorIsCurrent:
		(*target).IsCurrent = fpv.value.(bool)
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		(*target).PageTokenChange = fpv.value.(*WatchProjectsResponse_PageTokenChange)
	case WatchProjectsResponse_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
		(*target).SnapshotSize = fpv.value.(int64)
	case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
		(*target).IsSoftReset = fpv.value.(bool)
	case WatchProjectsResponse_FieldPathSelectorIsHardReset:
		(*target).IsHardReset = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fpv.selector))
	}
}

func (fpv *WatchProjectsResponse_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*WatchProjectsResponse)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'WatchProjectsResponse_FieldTerminalPathValue' with the value under path in 'WatchProjectsResponse'.
func (fpv *WatchProjectsResponse_FieldTerminalPathValue) CompareWith(source *WatchProjectsResponse) (int, bool) {
	switch fpv.selector {
	case WatchProjectsResponse_FieldPathSelectorProjectChanges:
		return 0, false
	case WatchProjectsResponse_FieldPathSelectorIsCurrent:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsCurrent()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		return 0, false
	case WatchProjectsResponse_FieldPathSelectorResumeToken:
		leftValue := fpv.value.(string)
		rightValue := source.GetResumeToken()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
		leftValue := fpv.value.(int64)
		rightValue := source.GetSnapshotSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsSoftReset()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchProjectsResponse_FieldPathSelectorIsHardReset:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsHardReset()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fpv.selector))
	}
}

func (fpv *WatchProjectsResponse_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*WatchProjectsResponse))
}

type WatchProjectsResponse_FieldSubPathValue struct {
	WatchProjectsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ WatchProjectsResponse_FieldPathValue = (*WatchProjectsResponse_FieldSubPathValue)(nil)

func (fpvs *WatchProjectsResponse_FieldSubPathValue) AsPageTokenChangePathValue() (WatchProjectsResponsePageTokenChange_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(WatchProjectsResponsePageTokenChange_FieldPathValue)
	return res, ok
}

func (fpvs *WatchProjectsResponse_FieldSubPathValue) SetTo(target **WatchProjectsResponse) {
	if *target == nil {
		*target = new(WatchProjectsResponse)
	}
	switch fpvs.Selector() {
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		fpvs.subPathValue.(WatchProjectsResponsePageTokenChange_FieldPathValue).SetTo(&(*target).PageTokenChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fpvs.Selector()))
	}
}

func (fpvs *WatchProjectsResponse_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*WatchProjectsResponse)
	fpvs.SetTo(&typedObject)
}

func (fpvs *WatchProjectsResponse_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *WatchProjectsResponse_FieldSubPathValue) CompareWith(source *WatchProjectsResponse) (int, bool) {
	switch fpvs.Selector() {
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		return fpvs.subPathValue.(WatchProjectsResponsePageTokenChange_FieldPathValue).CompareWith(source.GetPageTokenChange())
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fpvs.Selector()))
	}
}

func (fpvs *WatchProjectsResponse_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*WatchProjectsResponse))
}

// WatchProjectsResponse_FieldPathArrayItemValue allows storing single item in Path-specific values for WatchProjectsResponse according to their type
// Present only for array (repeated) types.
type WatchProjectsResponse_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	WatchProjectsResponse_FieldPath
	ContainsValue(*WatchProjectsResponse) bool
}

// ParseWatchProjectsResponse_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchProjectsResponse_FieldPathArrayItemValue(pathStr, valueStr string) (WatchProjectsResponse_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchProjectsResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectsResponse field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(WatchProjectsResponse_FieldPathArrayItemValue), nil
}

func MustParseWatchProjectsResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchProjectsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchProjectsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchProjectsResponse_FieldTerminalPathArrayItemValue struct {
	WatchProjectsResponse_FieldTerminalPath
	value interface{}
}

var _ WatchProjectsResponse_FieldPathArrayItemValue = (*WatchProjectsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchProjectsResponse as interface{}
func (fpaiv *WatchProjectsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *WatchProjectsResponse_FieldTerminalPathArrayItemValue) AsProjectChangesItemValue() (*project.ProjectChange, bool) {
	res, ok := fpaiv.value.(*project.ProjectChange)
	return res, ok
}

func (fpaiv *WatchProjectsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchProjectsResponse) (interface{}, bool) {
	return nil, false
}

func (fpaiv *WatchProjectsResponse_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*WatchProjectsResponse))
}

// Contains returns a boolean indicating if value that is being held is present in given 'WatchProjectsResponse'
func (fpaiv *WatchProjectsResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchProjectsResponse) bool {
	slice := fpaiv.WatchProjectsResponse_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type WatchProjectsResponse_FieldSubPathArrayItemValue struct {
	WatchProjectsResponse_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *WatchProjectsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *WatchProjectsResponse_FieldSubPathArrayItemValue) AsPageTokenChangePathItemValue() (WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'WatchProjectsResponse'
func (fpaivs *WatchProjectsResponse_FieldSubPathArrayItemValue) ContainsValue(source *WatchProjectsResponse) bool {
	switch fpaivs.Selector() {
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		return fpaivs.subPathItemValue.(WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue).ContainsValue(source.GetPageTokenChange())
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse: %d", fpaivs.Selector()))
	}
}

// WatchProjectsResponse_FieldPathArrayOfValues allows storing slice of values for WatchProjectsResponse fields according to their type
type WatchProjectsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchProjectsResponse_FieldPath
}

func ParseWatchProjectsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchProjectsResponse_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchProjectsResponse_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing WatchProjectsResponse field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(WatchProjectsResponse_FieldPathArrayOfValues), nil
}

func MustParseWatchProjectsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchProjectsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchProjectsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchProjectsResponse_FieldTerminalPathArrayOfValues struct {
	WatchProjectsResponse_FieldTerminalPath
	values interface{}
}

var _ WatchProjectsResponse_FieldPathArrayOfValues = (*WatchProjectsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchProjectsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchProjectsResponse_FieldPathSelectorProjectChanges:
		for _, v := range fpaov.values.([][]*project.ProjectChange) {
			values = append(values, v)
		}
	case WatchProjectsResponse_FieldPathSelectorIsCurrent:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchProjectsResponse_FieldPathSelectorPageTokenChange:
		for _, v := range fpaov.values.([]*WatchProjectsResponse_PageTokenChange) {
			values = append(values, v)
		}
	case WatchProjectsResponse_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchProjectsResponse_FieldPathSelectorSnapshotSize:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case WatchProjectsResponse_FieldPathSelectorIsSoftReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchProjectsResponse_FieldPathSelectorIsHardReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchProjectsResponse_FieldTerminalPathArrayOfValues) AsProjectChangesArrayOfValues() ([][]*project.ProjectChange, bool) {
	res, ok := fpaov.values.([][]*project.ProjectChange)
	return res, ok
}
func (fpaov *WatchProjectsResponse_FieldTerminalPathArrayOfValues) AsIsCurrentArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchProjectsResponse_FieldTerminalPathArrayOfValues) AsPageTokenChangeArrayOfValues() ([]*WatchProjectsResponse_PageTokenChange, bool) {
	res, ok := fpaov.values.([]*WatchProjectsResponse_PageTokenChange)
	return res, ok
}
func (fpaov *WatchProjectsResponse_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchProjectsResponse_FieldTerminalPathArrayOfValues) AsSnapshotSizeArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *WatchProjectsResponse_FieldTerminalPathArrayOfValues) AsIsSoftResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchProjectsResponse_FieldTerminalPathArrayOfValues) AsIsHardResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type WatchProjectsResponse_FieldSubPathArrayOfValues struct {
	WatchProjectsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ WatchProjectsResponse_FieldPathArrayOfValues = (*WatchProjectsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *WatchProjectsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *WatchProjectsResponse_FieldSubPathArrayOfValues) AsPageTokenChangePathArrayOfValues() (WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type WatchProjectsResponsePageTokenChange_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchProjectsResponsePageTokenChange_FieldPathSelector
	Get(source *WatchProjectsResponse_PageTokenChange) []interface{}
	GetSingle(source *WatchProjectsResponse_PageTokenChange) (interface{}, bool)
	ClearValue(item *WatchProjectsResponse_PageTokenChange)

	// Those methods build corresponding WatchProjectsResponsePageTokenChange_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) WatchProjectsResponsePageTokenChange_FieldPathValue
	WithIArrayOfValues(values interface{}) WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue
}

type WatchProjectsResponsePageTokenChange_FieldPathSelector int32

const (
	WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken WatchProjectsResponsePageTokenChange_FieldPathSelector = 0
	WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken WatchProjectsResponsePageTokenChange_FieldPathSelector = 1
)

func (s WatchProjectsResponsePageTokenChange_FieldPathSelector) String() string {
	switch s {
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return "next_page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", s))
	}
}

func BuildWatchProjectsResponsePageTokenChange_FieldPath(fp gotenobject.RawFieldPath) (WatchProjectsResponsePageTokenChange_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchProjectsResponse_PageTokenChange")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &WatchProjectsResponsePageTokenChange_FieldTerminalPath{selector: WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &WatchProjectsResponsePageTokenChange_FieldTerminalPath{selector: WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchProjectsResponse_PageTokenChange", fp)
}

func ParseWatchProjectsResponsePageTokenChange_FieldPath(rawField string) (WatchProjectsResponsePageTokenChange_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchProjectsResponsePageTokenChange_FieldPath(fp)
}

func MustParseWatchProjectsResponsePageTokenChange_FieldPath(rawField string) WatchProjectsResponsePageTokenChange_FieldPath {
	fp, err := ParseWatchProjectsResponsePageTokenChange_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchProjectsResponsePageTokenChange_FieldTerminalPath struct {
	selector WatchProjectsResponsePageTokenChange_FieldPathSelector
}

var _ WatchProjectsResponsePageTokenChange_FieldPath = (*WatchProjectsResponsePageTokenChange_FieldTerminalPath)(nil)

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) Selector() WatchProjectsResponsePageTokenChange_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source WatchProjectsResponse_PageTokenChange
func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) Get(source *WatchProjectsResponse_PageTokenChange) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
			if source.PrevPageToken != nil {
				values = append(values, source.PrevPageToken)
			}
		case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
			if source.NextPageToken != nil {
				values = append(values, source.NextPageToken)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", fp.selector))
		}
	}
	return
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*WatchProjectsResponse_PageTokenChange))
}

// GetSingle returns value pointed by specific field of from source WatchProjectsResponse_PageTokenChange
func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) GetSingle(source *WatchProjectsResponse_PageTokenChange) (interface{}, bool) {
	switch fp.selector {
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		res := source.GetPrevPageToken()
		return res, res != nil
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		res := source.GetNextPageToken()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*WatchProjectsResponse_PageTokenChange))
}

// GetDefault returns a default value of the field type
func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return (*project.PagerCursor)(nil)
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return (*project.PagerCursor)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) ClearValue(item *WatchProjectsResponse_PageTokenChange) {
	if item != nil {
		switch fp.selector {
		case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", fp.selector))
		}
	}
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchProjectsResponse_PageTokenChange))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken ||
		fp.selector == WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) WithIValue(value interface{}) WatchProjectsResponsePageTokenChange_FieldPathValue {
	switch fp.selector {
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchProjectsResponsePageTokenChange_FieldTerminalPathValue{WatchProjectsResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*project.PagerCursor)}
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchProjectsResponsePageTokenChange_FieldTerminalPathValue{WatchProjectsResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*project.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov := &WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchProjectsResponsePageTokenChange_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchProjectsResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*project.PagerCursor)}
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchProjectsResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*project.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", fp.selector))
	}
	return fpaov
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchProjectsResponsePageTokenChange_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// WatchProjectsResponsePageTokenChange_FieldPathValue allows storing values for PageTokenChange fields according to their type
type WatchProjectsResponsePageTokenChange_FieldPathValue interface {
	WatchProjectsResponsePageTokenChange_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **WatchProjectsResponse_PageTokenChange)
	CompareWith(*WatchProjectsResponse_PageTokenChange) (cmp int, comparable bool)
}

func ParseWatchProjectsResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) (WatchProjectsResponsePageTokenChange_FieldPathValue, error) {
	fp, err := ParseWatchProjectsResponsePageTokenChange_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing PageTokenChange field path value from %s: %v", valueStr, err)
	}
	return fpv.(WatchProjectsResponsePageTokenChange_FieldPathValue), nil
}

func MustParseWatchProjectsResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) WatchProjectsResponsePageTokenChange_FieldPathValue {
	fpv, err := ParseWatchProjectsResponsePageTokenChange_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchProjectsResponsePageTokenChange_FieldTerminalPathValue struct {
	WatchProjectsResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchProjectsResponsePageTokenChange_FieldPathValue = (*WatchProjectsResponsePageTokenChange_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PageTokenChange' as interface{}
func (fpv *WatchProjectsResponsePageTokenChange_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchProjectsResponsePageTokenChange_FieldTerminalPathValue) AsPrevPageTokenValue() (*project.PagerCursor, bool) {
	res, ok := fpv.value.(*project.PagerCursor)
	return res, ok
}
func (fpv *WatchProjectsResponsePageTokenChange_FieldTerminalPathValue) AsNextPageTokenValue() (*project.PagerCursor, bool) {
	res, ok := fpv.value.(*project.PagerCursor)
	return res, ok
}

// SetTo stores value for selected field for object PageTokenChange
func (fpv *WatchProjectsResponsePageTokenChange_FieldTerminalPathValue) SetTo(target **WatchProjectsResponse_PageTokenChange) {
	if *target == nil {
		*target = new(WatchProjectsResponse_PageTokenChange)
	}
	switch fpv.selector {
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*project.PagerCursor)
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*project.PagerCursor)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", fpv.selector))
	}
}

func (fpv *WatchProjectsResponsePageTokenChange_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*WatchProjectsResponse_PageTokenChange)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'WatchProjectsResponsePageTokenChange_FieldTerminalPathValue' with the value under path in 'WatchProjectsResponse_PageTokenChange'.
func (fpv *WatchProjectsResponsePageTokenChange_FieldTerminalPathValue) CompareWith(source *WatchProjectsResponse_PageTokenChange) (int, bool) {
	switch fpv.selector {
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return 0, false
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for WatchProjectsResponse_PageTokenChange: %d", fpv.selector))
	}
}

func (fpv *WatchProjectsResponsePageTokenChange_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*WatchProjectsResponse_PageTokenChange))
}

// WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue allows storing single item in Path-specific values for PageTokenChange according to their type
// Present only for array (repeated) types.
type WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	WatchProjectsResponsePageTokenChange_FieldPath
	ContainsValue(*WatchProjectsResponse_PageTokenChange) bool
}

// ParseWatchProjectsResponsePageTokenChange_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchProjectsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) (WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchProjectsResponsePageTokenChange_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing PageTokenChange field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue), nil
}

func MustParseWatchProjectsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchProjectsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayItemValue struct {
	WatchProjectsResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchProjectsResponsePageTokenChange_FieldPathArrayItemValue = (*WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchProjectsResponse_PageTokenChange as interface{}
func (fpaiv *WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayItemValue) GetSingle(source *WatchProjectsResponse_PageTokenChange) (interface{}, bool) {
	return nil, false
}

func (fpaiv *WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*WatchProjectsResponse_PageTokenChange))
}

// Contains returns a boolean indicating if value that is being held is present in given 'PageTokenChange'
func (fpaiv *WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchProjectsResponse_PageTokenChange) bool {
	slice := fpaiv.WatchProjectsResponsePageTokenChange_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues allows storing slice of values for PageTokenChange fields according to their type
type WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchProjectsResponsePageTokenChange_FieldPath
}

func ParseWatchProjectsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchProjectsResponsePageTokenChange_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing PageTokenChange field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues), nil
}

func MustParseWatchProjectsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov, err := ParseWatchProjectsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayOfValues struct {
	WatchProjectsResponsePageTokenChange_FieldTerminalPath
	values interface{}
}

var _ WatchProjectsResponsePageTokenChange_FieldPathArrayOfValues = (*WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*project.PagerCursor) {
			values = append(values, v)
		}
	case WatchProjectsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*project.PagerCursor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*project.PagerCursor, bool) {
	res, ok := fpaov.values.([]*project.PagerCursor)
	return res, ok
}
func (fpaov *WatchProjectsResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*project.PagerCursor, bool) {
	res, ok := fpaov.values.([]*project.PagerCursor)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type CreateProjectRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() CreateProjectRequest_FieldPathSelector
	Get(source *CreateProjectRequest) []interface{}
	GetSingle(source *CreateProjectRequest) (interface{}, bool)
	ClearValue(item *CreateProjectRequest)

	// Those methods build corresponding CreateProjectRequest_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) CreateProjectRequest_FieldPathValue
	WithIArrayOfValues(values interface{}) CreateProjectRequest_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) CreateProjectRequest_FieldPathArrayItemValue
}

type CreateProjectRequest_FieldPathSelector int32

const (
	CreateProjectRequest_FieldPathSelectorProject CreateProjectRequest_FieldPathSelector = 0
)

func (s CreateProjectRequest_FieldPathSelector) String() string {
	switch s {
	case CreateProjectRequest_FieldPathSelectorProject:
		return "project"
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", s))
	}
}

func BuildCreateProjectRequest_FieldPath(fp gotenobject.RawFieldPath) (CreateProjectRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreateProjectRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "project":
			return &CreateProjectRequest_FieldTerminalPath{selector: CreateProjectRequest_FieldPathSelectorProject}, nil
		}
	} else {
		switch fp[0] {
		case "project":
			if subpath, err := project.BuildProject_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateProjectRequest_FieldSubPath{selector: CreateProjectRequest_FieldPathSelectorProject, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreateProjectRequest", fp)
}

func ParseCreateProjectRequest_FieldPath(rawField string) (CreateProjectRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreateProjectRequest_FieldPath(fp)
}

func MustParseCreateProjectRequest_FieldPath(rawField string) CreateProjectRequest_FieldPath {
	fp, err := ParseCreateProjectRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreateProjectRequest_FieldTerminalPath struct {
	selector CreateProjectRequest_FieldPathSelector
}

var _ CreateProjectRequest_FieldPath = (*CreateProjectRequest_FieldTerminalPath)(nil)

func (fp *CreateProjectRequest_FieldTerminalPath) Selector() CreateProjectRequest_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *CreateProjectRequest_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *CreateProjectRequest_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source CreateProjectRequest
func (fp *CreateProjectRequest_FieldTerminalPath) Get(source *CreateProjectRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case CreateProjectRequest_FieldPathSelectorProject:
			if source.Project != nil {
				values = append(values, source.Project)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fp.selector))
		}
	}
	return
}

func (fp *CreateProjectRequest_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*CreateProjectRequest))
}

// GetSingle returns value pointed by specific field of from source CreateProjectRequest
func (fp *CreateProjectRequest_FieldTerminalPath) GetSingle(source *CreateProjectRequest) (interface{}, bool) {
	switch fp.selector {
	case CreateProjectRequest_FieldPathSelectorProject:
		res := source.GetProject()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fp.selector))
	}
}

func (fp *CreateProjectRequest_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*CreateProjectRequest))
}

// GetDefault returns a default value of the field type
func (fp *CreateProjectRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreateProjectRequest_FieldPathSelectorProject:
		return (*project.Project)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fp.selector))
	}
}

func (fp *CreateProjectRequest_FieldTerminalPath) ClearValue(item *CreateProjectRequest) {
	if item != nil {
		switch fp.selector {
		case CreateProjectRequest_FieldPathSelectorProject:
			item.Project = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fp.selector))
		}
	}
}

func (fp *CreateProjectRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreateProjectRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *CreateProjectRequest_FieldTerminalPath) IsLeaf() bool {
	return false
}

func (fp *CreateProjectRequest_FieldTerminalPath) WithIValue(value interface{}) CreateProjectRequest_FieldPathValue {
	switch fp.selector {
	case CreateProjectRequest_FieldPathSelectorProject:
		return &CreateProjectRequest_FieldTerminalPathValue{CreateProjectRequest_FieldTerminalPath: *fp, value: value.(*project.Project)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fp.selector))
	}
}

func (fp *CreateProjectRequest_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *CreateProjectRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreateProjectRequest_FieldPathArrayOfValues {
	fpaov := &CreateProjectRequest_FieldTerminalPathArrayOfValues{CreateProjectRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreateProjectRequest_FieldPathSelectorProject:
		return &CreateProjectRequest_FieldTerminalPathArrayOfValues{CreateProjectRequest_FieldTerminalPath: *fp, values: values.([]*project.Project)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fp.selector))
	}
	return fpaov
}

func (fp *CreateProjectRequest_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *CreateProjectRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) CreateProjectRequest_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fp.selector))
	}
}

func (fp *CreateProjectRequest_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type CreateProjectRequest_FieldSubPath struct {
	selector CreateProjectRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreateProjectRequest_FieldPath = (*CreateProjectRequest_FieldSubPath)(nil)

func (fps *CreateProjectRequest_FieldSubPath) Selector() CreateProjectRequest_FieldPathSelector {
	return fps.selector
}
func (fps *CreateProjectRequest_FieldSubPath) AsProjectSubPath() (project.Project_FieldPath, bool) {
	res, ok := fps.subPath.(project.Project_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *CreateProjectRequest_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *CreateProjectRequest_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source CreateProjectRequest
func (fps *CreateProjectRequest_FieldSubPath) Get(source *CreateProjectRequest) (values []interface{}) {
	if asProjectFieldPath, ok := fps.AsProjectSubPath(); ok {
		values = append(values, asProjectFieldPath.Get(source.GetProject())...)
	} else {
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fps.selector))
	}
	return
}

func (fps *CreateProjectRequest_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*CreateProjectRequest))
}

// GetSingle returns value of selected field from source CreateProjectRequest
func (fps *CreateProjectRequest_FieldSubPath) GetSingle(source *CreateProjectRequest) (interface{}, bool) {
	switch fps.selector {
	case CreateProjectRequest_FieldPathSelectorProject:
		if source.GetProject() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetProject())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fps.selector))
	}
}

func (fps *CreateProjectRequest_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*CreateProjectRequest))
}

// GetDefault returns a default value of the field type
func (fps *CreateProjectRequest_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *CreateProjectRequest_FieldSubPath) ClearValue(item *CreateProjectRequest) {
	if item != nil {
		switch fps.selector {
		case CreateProjectRequest_FieldPathSelectorProject:
			fps.subPath.ClearValueRaw(item.Project)
		default:
			panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fps.selector))
		}
	}
}

func (fps *CreateProjectRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreateProjectRequest))
}

// IsLeaf - whether field path is holds simple value
func (fps *CreateProjectRequest_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *CreateProjectRequest_FieldSubPath) WithIValue(value interface{}) CreateProjectRequest_FieldPathValue {
	return &CreateProjectRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *CreateProjectRequest_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *CreateProjectRequest_FieldSubPath) WithIArrayOfValues(values interface{}) CreateProjectRequest_FieldPathArrayOfValues {
	return &CreateProjectRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *CreateProjectRequest_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *CreateProjectRequest_FieldSubPath) WithIArrayItemValue(value interface{}) CreateProjectRequest_FieldPathArrayItemValue {
	return &CreateProjectRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *CreateProjectRequest_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// CreateProjectRequest_FieldPathValue allows storing values for CreateProjectRequest fields according to their type
type CreateProjectRequest_FieldPathValue interface {
	CreateProjectRequest_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **CreateProjectRequest)
	CompareWith(*CreateProjectRequest) (cmp int, comparable bool)
}

func ParseCreateProjectRequest_FieldPathValue(pathStr, valueStr string) (CreateProjectRequest_FieldPathValue, error) {
	fp, err := ParseCreateProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing CreateProjectRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(CreateProjectRequest_FieldPathValue), nil
}

func MustParseCreateProjectRequest_FieldPathValue(pathStr, valueStr string) CreateProjectRequest_FieldPathValue {
	fpv, err := ParseCreateProjectRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreateProjectRequest_FieldTerminalPathValue struct {
	CreateProjectRequest_FieldTerminalPath
	value interface{}
}

var _ CreateProjectRequest_FieldPathValue = (*CreateProjectRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreateProjectRequest' as interface{}
func (fpv *CreateProjectRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreateProjectRequest_FieldTerminalPathValue) AsProjectValue() (*project.Project, bool) {
	res, ok := fpv.value.(*project.Project)
	return res, ok
}

// SetTo stores value for selected field for object CreateProjectRequest
func (fpv *CreateProjectRequest_FieldTerminalPathValue) SetTo(target **CreateProjectRequest) {
	if *target == nil {
		*target = new(CreateProjectRequest)
	}
	switch fpv.selector {
	case CreateProjectRequest_FieldPathSelectorProject:
		(*target).Project = fpv.value.(*project.Project)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fpv.selector))
	}
}

func (fpv *CreateProjectRequest_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*CreateProjectRequest)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'CreateProjectRequest_FieldTerminalPathValue' with the value under path in 'CreateProjectRequest'.
func (fpv *CreateProjectRequest_FieldTerminalPathValue) CompareWith(source *CreateProjectRequest) (int, bool) {
	switch fpv.selector {
	case CreateProjectRequest_FieldPathSelectorProject:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fpv.selector))
	}
}

func (fpv *CreateProjectRequest_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*CreateProjectRequest))
}

type CreateProjectRequest_FieldSubPathValue struct {
	CreateProjectRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreateProjectRequest_FieldPathValue = (*CreateProjectRequest_FieldSubPathValue)(nil)

func (fpvs *CreateProjectRequest_FieldSubPathValue) AsProjectPathValue() (project.Project_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(project.Project_FieldPathValue)
	return res, ok
}

func (fpvs *CreateProjectRequest_FieldSubPathValue) SetTo(target **CreateProjectRequest) {
	if *target == nil {
		*target = new(CreateProjectRequest)
	}
	switch fpvs.Selector() {
	case CreateProjectRequest_FieldPathSelectorProject:
		fpvs.subPathValue.(project.Project_FieldPathValue).SetTo(&(*target).Project)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fpvs.Selector()))
	}
}

func (fpvs *CreateProjectRequest_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*CreateProjectRequest)
	fpvs.SetTo(&typedObject)
}

func (fpvs *CreateProjectRequest_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *CreateProjectRequest_FieldSubPathValue) CompareWith(source *CreateProjectRequest) (int, bool) {
	switch fpvs.Selector() {
	case CreateProjectRequest_FieldPathSelectorProject:
		return fpvs.subPathValue.(project.Project_FieldPathValue).CompareWith(source.GetProject())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fpvs.Selector()))
	}
}

func (fpvs *CreateProjectRequest_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*CreateProjectRequest))
}

// CreateProjectRequest_FieldPathArrayItemValue allows storing single item in Path-specific values for CreateProjectRequest according to their type
// Present only for array (repeated) types.
type CreateProjectRequest_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	CreateProjectRequest_FieldPath
	ContainsValue(*CreateProjectRequest) bool
}

// ParseCreateProjectRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseCreateProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) (CreateProjectRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseCreateProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing CreateProjectRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(CreateProjectRequest_FieldPathArrayItemValue), nil
}

func MustParseCreateProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) CreateProjectRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseCreateProjectRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreateProjectRequest_FieldTerminalPathArrayItemValue struct {
	CreateProjectRequest_FieldTerminalPath
	value interface{}
}

var _ CreateProjectRequest_FieldPathArrayItemValue = (*CreateProjectRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object CreateProjectRequest as interface{}
func (fpaiv *CreateProjectRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *CreateProjectRequest_FieldTerminalPathArrayItemValue) GetSingle(source *CreateProjectRequest) (interface{}, bool) {
	return nil, false
}

func (fpaiv *CreateProjectRequest_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*CreateProjectRequest))
}

// Contains returns a boolean indicating if value that is being held is present in given 'CreateProjectRequest'
func (fpaiv *CreateProjectRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *CreateProjectRequest) bool {
	slice := fpaiv.CreateProjectRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type CreateProjectRequest_FieldSubPathArrayItemValue struct {
	CreateProjectRequest_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *CreateProjectRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *CreateProjectRequest_FieldSubPathArrayItemValue) AsProjectPathItemValue() (project.Project_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(project.Project_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'CreateProjectRequest'
func (fpaivs *CreateProjectRequest_FieldSubPathArrayItemValue) ContainsValue(source *CreateProjectRequest) bool {
	switch fpaivs.Selector() {
	case CreateProjectRequest_FieldPathSelectorProject:
		return fpaivs.subPathItemValue.(project.Project_FieldPathArrayItemValue).ContainsValue(source.GetProject())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateProjectRequest: %d", fpaivs.Selector()))
	}
}

// CreateProjectRequest_FieldPathArrayOfValues allows storing slice of values for CreateProjectRequest fields according to their type
type CreateProjectRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreateProjectRequest_FieldPath
}

func ParseCreateProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (CreateProjectRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseCreateProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing CreateProjectRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(CreateProjectRequest_FieldPathArrayOfValues), nil
}

func MustParseCreateProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) CreateProjectRequest_FieldPathArrayOfValues {
	fpaov, err := ParseCreateProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreateProjectRequest_FieldTerminalPathArrayOfValues struct {
	CreateProjectRequest_FieldTerminalPath
	values interface{}
}

var _ CreateProjectRequest_FieldPathArrayOfValues = (*CreateProjectRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreateProjectRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreateProjectRequest_FieldPathSelectorProject:
		for _, v := range fpaov.values.([]*project.Project) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreateProjectRequest_FieldTerminalPathArrayOfValues) AsProjectArrayOfValues() ([]*project.Project, bool) {
	res, ok := fpaov.values.([]*project.Project)
	return res, ok
}

type CreateProjectRequest_FieldSubPathArrayOfValues struct {
	CreateProjectRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreateProjectRequest_FieldPathArrayOfValues = (*CreateProjectRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *CreateProjectRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *CreateProjectRequest_FieldSubPathArrayOfValues) AsProjectPathArrayOfValues() (project.Project_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(project.Project_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type UpdateProjectRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() UpdateProjectRequest_FieldPathSelector
	Get(source *UpdateProjectRequest) []interface{}
	GetSingle(source *UpdateProjectRequest) (interface{}, bool)
	ClearValue(item *UpdateProjectRequest)

	// Those methods build corresponding UpdateProjectRequest_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) UpdateProjectRequest_FieldPathValue
	WithIArrayOfValues(values interface{}) UpdateProjectRequest_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) UpdateProjectRequest_FieldPathArrayItemValue
}

type UpdateProjectRequest_FieldPathSelector int32

const (
	UpdateProjectRequest_FieldPathSelectorProject    UpdateProjectRequest_FieldPathSelector = 0
	UpdateProjectRequest_FieldPathSelectorUpdateMask UpdateProjectRequest_FieldPathSelector = 1
	UpdateProjectRequest_FieldPathSelectorCas        UpdateProjectRequest_FieldPathSelector = 2
)

func (s UpdateProjectRequest_FieldPathSelector) String() string {
	switch s {
	case UpdateProjectRequest_FieldPathSelectorProject:
		return "project"
	case UpdateProjectRequest_FieldPathSelectorUpdateMask:
		return "update_mask"
	case UpdateProjectRequest_FieldPathSelectorCas:
		return "cas"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", s))
	}
}

func BuildUpdateProjectRequest_FieldPath(fp gotenobject.RawFieldPath) (UpdateProjectRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateProjectRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "project":
			return &UpdateProjectRequest_FieldTerminalPath{selector: UpdateProjectRequest_FieldPathSelectorProject}, nil
		case "update_mask", "updateMask", "update-mask":
			return &UpdateProjectRequest_FieldTerminalPath{selector: UpdateProjectRequest_FieldPathSelectorUpdateMask}, nil
		case "cas":
			return &UpdateProjectRequest_FieldTerminalPath{selector: UpdateProjectRequest_FieldPathSelectorCas}, nil
		}
	} else {
		switch fp[0] {
		case "project":
			if subpath, err := project.BuildProject_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateProjectRequest_FieldSubPath{selector: UpdateProjectRequest_FieldPathSelectorProject, subPath: subpath}, nil
			}
		case "cas":
			if subpath, err := BuildUpdateProjectRequestCAS_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateProjectRequest_FieldSubPath{selector: UpdateProjectRequest_FieldPathSelectorCas, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateProjectRequest", fp)
}

func ParseUpdateProjectRequest_FieldPath(rawField string) (UpdateProjectRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateProjectRequest_FieldPath(fp)
}

func MustParseUpdateProjectRequest_FieldPath(rawField string) UpdateProjectRequest_FieldPath {
	fp, err := ParseUpdateProjectRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateProjectRequest_FieldTerminalPath struct {
	selector UpdateProjectRequest_FieldPathSelector
}

var _ UpdateProjectRequest_FieldPath = (*UpdateProjectRequest_FieldTerminalPath)(nil)

func (fp *UpdateProjectRequest_FieldTerminalPath) Selector() UpdateProjectRequest_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *UpdateProjectRequest_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *UpdateProjectRequest_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source UpdateProjectRequest
func (fp *UpdateProjectRequest_FieldTerminalPath) Get(source *UpdateProjectRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case UpdateProjectRequest_FieldPathSelectorProject:
			if source.Project != nil {
				values = append(values, source.Project)
			}
		case UpdateProjectRequest_FieldPathSelectorUpdateMask:
			if source.UpdateMask != nil {
				values = append(values, source.UpdateMask)
			}
		case UpdateProjectRequest_FieldPathSelectorCas:
			if source.Cas != nil {
				values = append(values, source.Cas)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fp.selector))
		}
	}
	return
}

func (fp *UpdateProjectRequest_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*UpdateProjectRequest))
}

// GetSingle returns value pointed by specific field of from source UpdateProjectRequest
func (fp *UpdateProjectRequest_FieldTerminalPath) GetSingle(source *UpdateProjectRequest) (interface{}, bool) {
	switch fp.selector {
	case UpdateProjectRequest_FieldPathSelectorProject:
		res := source.GetProject()
		return res, res != nil
	case UpdateProjectRequest_FieldPathSelectorUpdateMask:
		res := source.GetUpdateMask()
		return res, res != nil
	case UpdateProjectRequest_FieldPathSelectorCas:
		res := source.GetCas()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fp.selector))
	}
}

func (fp *UpdateProjectRequest_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*UpdateProjectRequest))
}

// GetDefault returns a default value of the field type
func (fp *UpdateProjectRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateProjectRequest_FieldPathSelectorProject:
		return (*project.Project)(nil)
	case UpdateProjectRequest_FieldPathSelectorUpdateMask:
		return (*project.Project_FieldMask)(nil)
	case UpdateProjectRequest_FieldPathSelectorCas:
		return (*UpdateProjectRequest_CAS)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fp.selector))
	}
}

func (fp *UpdateProjectRequest_FieldTerminalPath) ClearValue(item *UpdateProjectRequest) {
	if item != nil {
		switch fp.selector {
		case UpdateProjectRequest_FieldPathSelectorProject:
			item.Project = nil
		case UpdateProjectRequest_FieldPathSelectorUpdateMask:
			item.UpdateMask = nil
		case UpdateProjectRequest_FieldPathSelectorCas:
			item.Cas = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fp.selector))
		}
	}
}

func (fp *UpdateProjectRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateProjectRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *UpdateProjectRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == UpdateProjectRequest_FieldPathSelectorUpdateMask
}

func (fp *UpdateProjectRequest_FieldTerminalPath) WithIValue(value interface{}) UpdateProjectRequest_FieldPathValue {
	switch fp.selector {
	case UpdateProjectRequest_FieldPathSelectorProject:
		return &UpdateProjectRequest_FieldTerminalPathValue{UpdateProjectRequest_FieldTerminalPath: *fp, value: value.(*project.Project)}
	case UpdateProjectRequest_FieldPathSelectorUpdateMask:
		return &UpdateProjectRequest_FieldTerminalPathValue{UpdateProjectRequest_FieldTerminalPath: *fp, value: value.(*project.Project_FieldMask)}
	case UpdateProjectRequest_FieldPathSelectorCas:
		return &UpdateProjectRequest_FieldTerminalPathValue{UpdateProjectRequest_FieldTerminalPath: *fp, value: value.(*UpdateProjectRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fp.selector))
	}
}

func (fp *UpdateProjectRequest_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *UpdateProjectRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateProjectRequest_FieldPathArrayOfValues {
	fpaov := &UpdateProjectRequest_FieldTerminalPathArrayOfValues{UpdateProjectRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateProjectRequest_FieldPathSelectorProject:
		return &UpdateProjectRequest_FieldTerminalPathArrayOfValues{UpdateProjectRequest_FieldTerminalPath: *fp, values: values.([]*project.Project)}
	case UpdateProjectRequest_FieldPathSelectorUpdateMask:
		return &UpdateProjectRequest_FieldTerminalPathArrayOfValues{UpdateProjectRequest_FieldTerminalPath: *fp, values: values.([]*project.Project_FieldMask)}
	case UpdateProjectRequest_FieldPathSelectorCas:
		return &UpdateProjectRequest_FieldTerminalPathArrayOfValues{UpdateProjectRequest_FieldTerminalPath: *fp, values: values.([]*UpdateProjectRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fp.selector))
	}
	return fpaov
}

func (fp *UpdateProjectRequest_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *UpdateProjectRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) UpdateProjectRequest_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fp.selector))
	}
}

func (fp *UpdateProjectRequest_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type UpdateProjectRequest_FieldSubPath struct {
	selector UpdateProjectRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateProjectRequest_FieldPath = (*UpdateProjectRequest_FieldSubPath)(nil)

func (fps *UpdateProjectRequest_FieldSubPath) Selector() UpdateProjectRequest_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateProjectRequest_FieldSubPath) AsProjectSubPath() (project.Project_FieldPath, bool) {
	res, ok := fps.subPath.(project.Project_FieldPath)
	return res, ok
}
func (fps *UpdateProjectRequest_FieldSubPath) AsCasSubPath() (UpdateProjectRequestCAS_FieldPath, bool) {
	res, ok := fps.subPath.(UpdateProjectRequestCAS_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *UpdateProjectRequest_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *UpdateProjectRequest_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source UpdateProjectRequest
func (fps *UpdateProjectRequest_FieldSubPath) Get(source *UpdateProjectRequest) (values []interface{}) {
	if asProjectFieldPath, ok := fps.AsProjectSubPath(); ok {
		values = append(values, asProjectFieldPath.Get(source.GetProject())...)
	} else if asCASFieldPath, ok := fps.AsCasSubPath(); ok {
		values = append(values, asCASFieldPath.Get(source.GetCas())...)
	} else {
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fps.selector))
	}
	return
}

func (fps *UpdateProjectRequest_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*UpdateProjectRequest))
}

// GetSingle returns value of selected field from source UpdateProjectRequest
func (fps *UpdateProjectRequest_FieldSubPath) GetSingle(source *UpdateProjectRequest) (interface{}, bool) {
	switch fps.selector {
	case UpdateProjectRequest_FieldPathSelectorProject:
		if source.GetProject() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetProject())
	case UpdateProjectRequest_FieldPathSelectorCas:
		if source.GetCas() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fps.selector))
	}
}

func (fps *UpdateProjectRequest_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*UpdateProjectRequest))
}

// GetDefault returns a default value of the field type
func (fps *UpdateProjectRequest_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *UpdateProjectRequest_FieldSubPath) ClearValue(item *UpdateProjectRequest) {
	if item != nil {
		switch fps.selector {
		case UpdateProjectRequest_FieldPathSelectorProject:
			fps.subPath.ClearValueRaw(item.Project)
		case UpdateProjectRequest_FieldPathSelectorCas:
			fps.subPath.ClearValueRaw(item.Cas)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fps.selector))
		}
	}
}

func (fps *UpdateProjectRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateProjectRequest))
}

// IsLeaf - whether field path is holds simple value
func (fps *UpdateProjectRequest_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *UpdateProjectRequest_FieldSubPath) WithIValue(value interface{}) UpdateProjectRequest_FieldPathValue {
	return &UpdateProjectRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *UpdateProjectRequest_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *UpdateProjectRequest_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateProjectRequest_FieldPathArrayOfValues {
	return &UpdateProjectRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *UpdateProjectRequest_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *UpdateProjectRequest_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateProjectRequest_FieldPathArrayItemValue {
	return &UpdateProjectRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *UpdateProjectRequest_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// UpdateProjectRequest_FieldPathValue allows storing values for UpdateProjectRequest fields according to their type
type UpdateProjectRequest_FieldPathValue interface {
	UpdateProjectRequest_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **UpdateProjectRequest)
	CompareWith(*UpdateProjectRequest) (cmp int, comparable bool)
}

func ParseUpdateProjectRequest_FieldPathValue(pathStr, valueStr string) (UpdateProjectRequest_FieldPathValue, error) {
	fp, err := ParseUpdateProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing UpdateProjectRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(UpdateProjectRequest_FieldPathValue), nil
}

func MustParseUpdateProjectRequest_FieldPathValue(pathStr, valueStr string) UpdateProjectRequest_FieldPathValue {
	fpv, err := ParseUpdateProjectRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateProjectRequest_FieldTerminalPathValue struct {
	UpdateProjectRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateProjectRequest_FieldPathValue = (*UpdateProjectRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'UpdateProjectRequest' as interface{}
func (fpv *UpdateProjectRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateProjectRequest_FieldTerminalPathValue) AsProjectValue() (*project.Project, bool) {
	res, ok := fpv.value.(*project.Project)
	return res, ok
}
func (fpv *UpdateProjectRequest_FieldTerminalPathValue) AsUpdateMaskValue() (*project.Project_FieldMask, bool) {
	res, ok := fpv.value.(*project.Project_FieldMask)
	return res, ok
}
func (fpv *UpdateProjectRequest_FieldTerminalPathValue) AsCasValue() (*UpdateProjectRequest_CAS, bool) {
	res, ok := fpv.value.(*UpdateProjectRequest_CAS)
	return res, ok
}

// SetTo stores value for selected field for object UpdateProjectRequest
func (fpv *UpdateProjectRequest_FieldTerminalPathValue) SetTo(target **UpdateProjectRequest) {
	if *target == nil {
		*target = new(UpdateProjectRequest)
	}
	switch fpv.selector {
	case UpdateProjectRequest_FieldPathSelectorProject:
		(*target).Project = fpv.value.(*project.Project)
	case UpdateProjectRequest_FieldPathSelectorUpdateMask:
		(*target).UpdateMask = fpv.value.(*project.Project_FieldMask)
	case UpdateProjectRequest_FieldPathSelectorCas:
		(*target).Cas = fpv.value.(*UpdateProjectRequest_CAS)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fpv.selector))
	}
}

func (fpv *UpdateProjectRequest_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*UpdateProjectRequest)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'UpdateProjectRequest_FieldTerminalPathValue' with the value under path in 'UpdateProjectRequest'.
func (fpv *UpdateProjectRequest_FieldTerminalPathValue) CompareWith(source *UpdateProjectRequest) (int, bool) {
	switch fpv.selector {
	case UpdateProjectRequest_FieldPathSelectorProject:
		return 0, false
	case UpdateProjectRequest_FieldPathSelectorUpdateMask:
		return 0, false
	case UpdateProjectRequest_FieldPathSelectorCas:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fpv.selector))
	}
}

func (fpv *UpdateProjectRequest_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*UpdateProjectRequest))
}

type UpdateProjectRequest_FieldSubPathValue struct {
	UpdateProjectRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateProjectRequest_FieldPathValue = (*UpdateProjectRequest_FieldSubPathValue)(nil)

func (fpvs *UpdateProjectRequest_FieldSubPathValue) AsProjectPathValue() (project.Project_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(project.Project_FieldPathValue)
	return res, ok
}
func (fpvs *UpdateProjectRequest_FieldSubPathValue) AsCasPathValue() (UpdateProjectRequestCAS_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(UpdateProjectRequestCAS_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateProjectRequest_FieldSubPathValue) SetTo(target **UpdateProjectRequest) {
	if *target == nil {
		*target = new(UpdateProjectRequest)
	}
	switch fpvs.Selector() {
	case UpdateProjectRequest_FieldPathSelectorProject:
		fpvs.subPathValue.(project.Project_FieldPathValue).SetTo(&(*target).Project)
	case UpdateProjectRequest_FieldPathSelectorCas:
		fpvs.subPathValue.(UpdateProjectRequestCAS_FieldPathValue).SetTo(&(*target).Cas)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fpvs.Selector()))
	}
}

func (fpvs *UpdateProjectRequest_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*UpdateProjectRequest)
	fpvs.SetTo(&typedObject)
}

func (fpvs *UpdateProjectRequest_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *UpdateProjectRequest_FieldSubPathValue) CompareWith(source *UpdateProjectRequest) (int, bool) {
	switch fpvs.Selector() {
	case UpdateProjectRequest_FieldPathSelectorProject:
		return fpvs.subPathValue.(project.Project_FieldPathValue).CompareWith(source.GetProject())
	case UpdateProjectRequest_FieldPathSelectorCas:
		return fpvs.subPathValue.(UpdateProjectRequestCAS_FieldPathValue).CompareWith(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fpvs.Selector()))
	}
}

func (fpvs *UpdateProjectRequest_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*UpdateProjectRequest))
}

// UpdateProjectRequest_FieldPathArrayItemValue allows storing single item in Path-specific values for UpdateProjectRequest according to their type
// Present only for array (repeated) types.
type UpdateProjectRequest_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	UpdateProjectRequest_FieldPath
	ContainsValue(*UpdateProjectRequest) bool
}

// ParseUpdateProjectRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseUpdateProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) (UpdateProjectRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseUpdateProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing UpdateProjectRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(UpdateProjectRequest_FieldPathArrayItemValue), nil
}

func MustParseUpdateProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) UpdateProjectRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateProjectRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateProjectRequest_FieldTerminalPathArrayItemValue struct {
	UpdateProjectRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateProjectRequest_FieldPathArrayItemValue = (*UpdateProjectRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object UpdateProjectRequest as interface{}
func (fpaiv *UpdateProjectRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *UpdateProjectRequest_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateProjectRequest) (interface{}, bool) {
	return nil, false
}

func (fpaiv *UpdateProjectRequest_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*UpdateProjectRequest))
}

// Contains returns a boolean indicating if value that is being held is present in given 'UpdateProjectRequest'
func (fpaiv *UpdateProjectRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *UpdateProjectRequest) bool {
	slice := fpaiv.UpdateProjectRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type UpdateProjectRequest_FieldSubPathArrayItemValue struct {
	UpdateProjectRequest_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *UpdateProjectRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdateProjectRequest_FieldSubPathArrayItemValue) AsProjectPathItemValue() (project.Project_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(project.Project_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *UpdateProjectRequest_FieldSubPathArrayItemValue) AsCasPathItemValue() (UpdateProjectRequestCAS_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(UpdateProjectRequestCAS_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'UpdateProjectRequest'
func (fpaivs *UpdateProjectRequest_FieldSubPathArrayItemValue) ContainsValue(source *UpdateProjectRequest) bool {
	switch fpaivs.Selector() {
	case UpdateProjectRequest_FieldPathSelectorProject:
		return fpaivs.subPathItemValue.(project.Project_FieldPathArrayItemValue).ContainsValue(source.GetProject())
	case UpdateProjectRequest_FieldPathSelectorCas:
		return fpaivs.subPathItemValue.(UpdateProjectRequestCAS_FieldPathArrayItemValue).ContainsValue(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest: %d", fpaivs.Selector()))
	}
}

// UpdateProjectRequest_FieldPathArrayOfValues allows storing slice of values for UpdateProjectRequest fields according to their type
type UpdateProjectRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdateProjectRequest_FieldPath
}

func ParseUpdateProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (UpdateProjectRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseUpdateProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing UpdateProjectRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(UpdateProjectRequest_FieldPathArrayOfValues), nil
}

func MustParseUpdateProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateProjectRequest_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateProjectRequest_FieldTerminalPathArrayOfValues struct {
	UpdateProjectRequest_FieldTerminalPath
	values interface{}
}

var _ UpdateProjectRequest_FieldPathArrayOfValues = (*UpdateProjectRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateProjectRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateProjectRequest_FieldPathSelectorProject:
		for _, v := range fpaov.values.([]*project.Project) {
			values = append(values, v)
		}
	case UpdateProjectRequest_FieldPathSelectorUpdateMask:
		for _, v := range fpaov.values.([]*project.Project_FieldMask) {
			values = append(values, v)
		}
	case UpdateProjectRequest_FieldPathSelectorCas:
		for _, v := range fpaov.values.([]*UpdateProjectRequest_CAS) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateProjectRequest_FieldTerminalPathArrayOfValues) AsProjectArrayOfValues() ([]*project.Project, bool) {
	res, ok := fpaov.values.([]*project.Project)
	return res, ok
}
func (fpaov *UpdateProjectRequest_FieldTerminalPathArrayOfValues) AsUpdateMaskArrayOfValues() ([]*project.Project_FieldMask, bool) {
	res, ok := fpaov.values.([]*project.Project_FieldMask)
	return res, ok
}
func (fpaov *UpdateProjectRequest_FieldTerminalPathArrayOfValues) AsCasArrayOfValues() ([]*UpdateProjectRequest_CAS, bool) {
	res, ok := fpaov.values.([]*UpdateProjectRequest_CAS)
	return res, ok
}

type UpdateProjectRequest_FieldSubPathArrayOfValues struct {
	UpdateProjectRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateProjectRequest_FieldPathArrayOfValues = (*UpdateProjectRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateProjectRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateProjectRequest_FieldSubPathArrayOfValues) AsProjectPathArrayOfValues() (project.Project_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(project.Project_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *UpdateProjectRequest_FieldSubPathArrayOfValues) AsCasPathArrayOfValues() (UpdateProjectRequestCAS_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(UpdateProjectRequestCAS_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type UpdateProjectRequestCAS_FieldPath interface {
	gotenobject.FieldPath
	Selector() UpdateProjectRequestCAS_FieldPathSelector
	Get(source *UpdateProjectRequest_CAS) []interface{}
	GetSingle(source *UpdateProjectRequest_CAS) (interface{}, bool)
	ClearValue(item *UpdateProjectRequest_CAS)

	// Those methods build corresponding UpdateProjectRequestCAS_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) UpdateProjectRequestCAS_FieldPathValue
	WithIArrayOfValues(values interface{}) UpdateProjectRequestCAS_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) UpdateProjectRequestCAS_FieldPathArrayItemValue
}

type UpdateProjectRequestCAS_FieldPathSelector int32

const (
	UpdateProjectRequestCAS_FieldPathSelectorConditionalState UpdateProjectRequestCAS_FieldPathSelector = 0
	UpdateProjectRequestCAS_FieldPathSelectorFieldMask        UpdateProjectRequestCAS_FieldPathSelector = 1
)

func (s UpdateProjectRequestCAS_FieldPathSelector) String() string {
	switch s {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		return "conditional_state"
	case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
		return "field_mask"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", s))
	}
}

func BuildUpdateProjectRequestCAS_FieldPath(fp gotenobject.RawFieldPath) (UpdateProjectRequestCAS_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateProjectRequest_CAS")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			return &UpdateProjectRequestCAS_FieldTerminalPath{selector: UpdateProjectRequestCAS_FieldPathSelectorConditionalState}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &UpdateProjectRequestCAS_FieldTerminalPath{selector: UpdateProjectRequestCAS_FieldPathSelectorFieldMask}, nil
		}
	} else {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			if subpath, err := project.BuildProject_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateProjectRequestCAS_FieldSubPath{selector: UpdateProjectRequestCAS_FieldPathSelectorConditionalState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateProjectRequest_CAS", fp)
}

func ParseUpdateProjectRequestCAS_FieldPath(rawField string) (UpdateProjectRequestCAS_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateProjectRequestCAS_FieldPath(fp)
}

func MustParseUpdateProjectRequestCAS_FieldPath(rawField string) UpdateProjectRequestCAS_FieldPath {
	fp, err := ParseUpdateProjectRequestCAS_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateProjectRequestCAS_FieldTerminalPath struct {
	selector UpdateProjectRequestCAS_FieldPathSelector
}

var _ UpdateProjectRequestCAS_FieldPath = (*UpdateProjectRequestCAS_FieldTerminalPath)(nil)

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) Selector() UpdateProjectRequestCAS_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *UpdateProjectRequestCAS_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *UpdateProjectRequestCAS_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source UpdateProjectRequest_CAS
func (fp *UpdateProjectRequestCAS_FieldTerminalPath) Get(source *UpdateProjectRequest_CAS) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
			if source.ConditionalState != nil {
				values = append(values, source.ConditionalState)
			}
		case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fp.selector))
		}
	}
	return
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*UpdateProjectRequest_CAS))
}

// GetSingle returns value pointed by specific field of from source UpdateProjectRequest_CAS
func (fp *UpdateProjectRequestCAS_FieldTerminalPath) GetSingle(source *UpdateProjectRequest_CAS) (interface{}, bool) {
	switch fp.selector {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		res := source.GetConditionalState()
		return res, res != nil
	case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*UpdateProjectRequest_CAS))
}

// GetDefault returns a default value of the field type
func (fp *UpdateProjectRequestCAS_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		return (*project.Project)(nil)
	case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
		return (*project.Project_FieldMask)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) ClearValue(item *UpdateProjectRequest_CAS) {
	if item != nil {
		switch fp.selector {
		case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
			item.ConditionalState = nil
		case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fp.selector))
		}
	}
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateProjectRequest_CAS))
}

// IsLeaf - whether field path is holds simple value
func (fp *UpdateProjectRequestCAS_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == UpdateProjectRequestCAS_FieldPathSelectorFieldMask
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) WithIValue(value interface{}) UpdateProjectRequestCAS_FieldPathValue {
	switch fp.selector {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateProjectRequestCAS_FieldTerminalPathValue{UpdateProjectRequestCAS_FieldTerminalPath: *fp, value: value.(*project.Project)}
	case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateProjectRequestCAS_FieldTerminalPathValue{UpdateProjectRequestCAS_FieldTerminalPath: *fp, value: value.(*project.Project_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateProjectRequestCAS_FieldPathArrayOfValues {
	fpaov := &UpdateProjectRequestCAS_FieldTerminalPathArrayOfValues{UpdateProjectRequestCAS_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateProjectRequestCAS_FieldTerminalPathArrayOfValues{UpdateProjectRequestCAS_FieldTerminalPath: *fp, values: values.([]*project.Project)}
	case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateProjectRequestCAS_FieldTerminalPathArrayOfValues{UpdateProjectRequestCAS_FieldTerminalPath: *fp, values: values.([]*project.Project_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fp.selector))
	}
	return fpaov
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) WithIArrayItemValue(value interface{}) UpdateProjectRequestCAS_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdateProjectRequestCAS_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type UpdateProjectRequestCAS_FieldSubPath struct {
	selector UpdateProjectRequestCAS_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateProjectRequestCAS_FieldPath = (*UpdateProjectRequestCAS_FieldSubPath)(nil)

func (fps *UpdateProjectRequestCAS_FieldSubPath) Selector() UpdateProjectRequestCAS_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateProjectRequestCAS_FieldSubPath) AsConditionalStateSubPath() (project.Project_FieldPath, bool) {
	res, ok := fps.subPath.(project.Project_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *UpdateProjectRequestCAS_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *UpdateProjectRequestCAS_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source UpdateProjectRequest_CAS
func (fps *UpdateProjectRequestCAS_FieldSubPath) Get(source *UpdateProjectRequest_CAS) (values []interface{}) {
	if asProjectFieldPath, ok := fps.AsConditionalStateSubPath(); ok {
		values = append(values, asProjectFieldPath.Get(source.GetConditionalState())...)
	} else {
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fps.selector))
	}
	return
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*UpdateProjectRequest_CAS))
}

// GetSingle returns value of selected field from source UpdateProjectRequest_CAS
func (fps *UpdateProjectRequestCAS_FieldSubPath) GetSingle(source *UpdateProjectRequest_CAS) (interface{}, bool) {
	switch fps.selector {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		if source.GetConditionalState() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fps.selector))
	}
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*UpdateProjectRequest_CAS))
}

// GetDefault returns a default value of the field type
func (fps *UpdateProjectRequestCAS_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) ClearValue(item *UpdateProjectRequest_CAS) {
	if item != nil {
		switch fps.selector {
		case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
			fps.subPath.ClearValueRaw(item.ConditionalState)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fps.selector))
		}
	}
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateProjectRequest_CAS))
}

// IsLeaf - whether field path is holds simple value
func (fps *UpdateProjectRequestCAS_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) WithIValue(value interface{}) UpdateProjectRequestCAS_FieldPathValue {
	return &UpdateProjectRequestCAS_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateProjectRequestCAS_FieldPathArrayOfValues {
	return &UpdateProjectRequestCAS_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateProjectRequestCAS_FieldPathArrayItemValue {
	return &UpdateProjectRequestCAS_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *UpdateProjectRequestCAS_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// UpdateProjectRequestCAS_FieldPathValue allows storing values for CAS fields according to their type
type UpdateProjectRequestCAS_FieldPathValue interface {
	UpdateProjectRequestCAS_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **UpdateProjectRequest_CAS)
	CompareWith(*UpdateProjectRequest_CAS) (cmp int, comparable bool)
}

func ParseUpdateProjectRequestCAS_FieldPathValue(pathStr, valueStr string) (UpdateProjectRequestCAS_FieldPathValue, error) {
	fp, err := ParseUpdateProjectRequestCAS_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing CAS field path value from %s: %v", valueStr, err)
	}
	return fpv.(UpdateProjectRequestCAS_FieldPathValue), nil
}

func MustParseUpdateProjectRequestCAS_FieldPathValue(pathStr, valueStr string) UpdateProjectRequestCAS_FieldPathValue {
	fpv, err := ParseUpdateProjectRequestCAS_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateProjectRequestCAS_FieldTerminalPathValue struct {
	UpdateProjectRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateProjectRequestCAS_FieldPathValue = (*UpdateProjectRequestCAS_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CAS' as interface{}
func (fpv *UpdateProjectRequestCAS_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateProjectRequestCAS_FieldTerminalPathValue) AsConditionalStateValue() (*project.Project, bool) {
	res, ok := fpv.value.(*project.Project)
	return res, ok
}
func (fpv *UpdateProjectRequestCAS_FieldTerminalPathValue) AsFieldMaskValue() (*project.Project_FieldMask, bool) {
	res, ok := fpv.value.(*project.Project_FieldMask)
	return res, ok
}

// SetTo stores value for selected field for object CAS
func (fpv *UpdateProjectRequestCAS_FieldTerminalPathValue) SetTo(target **UpdateProjectRequest_CAS) {
	if *target == nil {
		*target = new(UpdateProjectRequest_CAS)
	}
	switch fpv.selector {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		(*target).ConditionalState = fpv.value.(*project.Project)
	case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*project.Project_FieldMask)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fpv.selector))
	}
}

func (fpv *UpdateProjectRequestCAS_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*UpdateProjectRequest_CAS)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'UpdateProjectRequestCAS_FieldTerminalPathValue' with the value under path in 'UpdateProjectRequest_CAS'.
func (fpv *UpdateProjectRequestCAS_FieldTerminalPathValue) CompareWith(source *UpdateProjectRequest_CAS) (int, bool) {
	switch fpv.selector {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		return 0, false
	case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fpv.selector))
	}
}

func (fpv *UpdateProjectRequestCAS_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*UpdateProjectRequest_CAS))
}

type UpdateProjectRequestCAS_FieldSubPathValue struct {
	UpdateProjectRequestCAS_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateProjectRequestCAS_FieldPathValue = (*UpdateProjectRequestCAS_FieldSubPathValue)(nil)

func (fpvs *UpdateProjectRequestCAS_FieldSubPathValue) AsConditionalStatePathValue() (project.Project_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(project.Project_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateProjectRequestCAS_FieldSubPathValue) SetTo(target **UpdateProjectRequest_CAS) {
	if *target == nil {
		*target = new(UpdateProjectRequest_CAS)
	}
	switch fpvs.Selector() {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		fpvs.subPathValue.(project.Project_FieldPathValue).SetTo(&(*target).ConditionalState)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fpvs.Selector()))
	}
}

func (fpvs *UpdateProjectRequestCAS_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*UpdateProjectRequest_CAS)
	fpvs.SetTo(&typedObject)
}

func (fpvs *UpdateProjectRequestCAS_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *UpdateProjectRequestCAS_FieldSubPathValue) CompareWith(source *UpdateProjectRequest_CAS) (int, bool) {
	switch fpvs.Selector() {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		return fpvs.subPathValue.(project.Project_FieldPathValue).CompareWith(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fpvs.Selector()))
	}
}

func (fpvs *UpdateProjectRequestCAS_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*UpdateProjectRequest_CAS))
}

// UpdateProjectRequestCAS_FieldPathArrayItemValue allows storing single item in Path-specific values for CAS according to their type
// Present only for array (repeated) types.
type UpdateProjectRequestCAS_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	UpdateProjectRequestCAS_FieldPath
	ContainsValue(*UpdateProjectRequest_CAS) bool
}

// ParseUpdateProjectRequestCAS_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseUpdateProjectRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) (UpdateProjectRequestCAS_FieldPathArrayItemValue, error) {
	fp, err := ParseUpdateProjectRequestCAS_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing CAS field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(UpdateProjectRequestCAS_FieldPathArrayItemValue), nil
}

func MustParseUpdateProjectRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) UpdateProjectRequestCAS_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateProjectRequestCAS_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateProjectRequestCAS_FieldTerminalPathArrayItemValue struct {
	UpdateProjectRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateProjectRequestCAS_FieldPathArrayItemValue = (*UpdateProjectRequestCAS_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object UpdateProjectRequest_CAS as interface{}
func (fpaiv *UpdateProjectRequestCAS_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *UpdateProjectRequestCAS_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateProjectRequest_CAS) (interface{}, bool) {
	return nil, false
}

func (fpaiv *UpdateProjectRequestCAS_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*UpdateProjectRequest_CAS))
}

// Contains returns a boolean indicating if value that is being held is present in given 'CAS'
func (fpaiv *UpdateProjectRequestCAS_FieldTerminalPathArrayItemValue) ContainsValue(source *UpdateProjectRequest_CAS) bool {
	slice := fpaiv.UpdateProjectRequestCAS_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type UpdateProjectRequestCAS_FieldSubPathArrayItemValue struct {
	UpdateProjectRequestCAS_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *UpdateProjectRequestCAS_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdateProjectRequestCAS_FieldSubPathArrayItemValue) AsConditionalStatePathItemValue() (project.Project_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(project.Project_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'CAS'
func (fpaivs *UpdateProjectRequestCAS_FieldSubPathArrayItemValue) ContainsValue(source *UpdateProjectRequest_CAS) bool {
	switch fpaivs.Selector() {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		return fpaivs.subPathItemValue.(project.Project_FieldPathArrayItemValue).ContainsValue(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateProjectRequest_CAS: %d", fpaivs.Selector()))
	}
}

// UpdateProjectRequestCAS_FieldPathArrayOfValues allows storing slice of values for CAS fields according to their type
type UpdateProjectRequestCAS_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdateProjectRequestCAS_FieldPath
}

func ParseUpdateProjectRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) (UpdateProjectRequestCAS_FieldPathArrayOfValues, error) {
	fp, err := ParseUpdateProjectRequestCAS_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing CAS field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(UpdateProjectRequestCAS_FieldPathArrayOfValues), nil
}

func MustParseUpdateProjectRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateProjectRequestCAS_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateProjectRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateProjectRequestCAS_FieldTerminalPathArrayOfValues struct {
	UpdateProjectRequestCAS_FieldTerminalPath
	values interface{}
}

var _ UpdateProjectRequestCAS_FieldPathArrayOfValues = (*UpdateProjectRequestCAS_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateProjectRequestCAS_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateProjectRequestCAS_FieldPathSelectorConditionalState:
		for _, v := range fpaov.values.([]*project.Project) {
			values = append(values, v)
		}
	case UpdateProjectRequestCAS_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*project.Project_FieldMask) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateProjectRequestCAS_FieldTerminalPathArrayOfValues) AsConditionalStateArrayOfValues() ([]*project.Project, bool) {
	res, ok := fpaov.values.([]*project.Project)
	return res, ok
}
func (fpaov *UpdateProjectRequestCAS_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*project.Project_FieldMask, bool) {
	res, ok := fpaov.values.([]*project.Project_FieldMask)
	return res, ok
}

type UpdateProjectRequestCAS_FieldSubPathArrayOfValues struct {
	UpdateProjectRequestCAS_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateProjectRequestCAS_FieldPathArrayOfValues = (*UpdateProjectRequestCAS_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateProjectRequestCAS_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateProjectRequestCAS_FieldSubPathArrayOfValues) AsConditionalStatePathArrayOfValues() (project.Project_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(project.Project_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type DeleteProjectRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() DeleteProjectRequest_FieldPathSelector
	Get(source *DeleteProjectRequest) []interface{}
	GetSingle(source *DeleteProjectRequest) (interface{}, bool)
	ClearValue(item *DeleteProjectRequest)

	// Those methods build corresponding DeleteProjectRequest_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) DeleteProjectRequest_FieldPathValue
	WithIArrayOfValues(values interface{}) DeleteProjectRequest_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) DeleteProjectRequest_FieldPathArrayItemValue
}

type DeleteProjectRequest_FieldPathSelector int32

const (
	DeleteProjectRequest_FieldPathSelectorName DeleteProjectRequest_FieldPathSelector = 0
)

func (s DeleteProjectRequest_FieldPathSelector) String() string {
	switch s {
	case DeleteProjectRequest_FieldPathSelectorName:
		return "name"
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", s))
	}
}

func BuildDeleteProjectRequest_FieldPath(fp gotenobject.RawFieldPath) (DeleteProjectRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object DeleteProjectRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &DeleteProjectRequest_FieldTerminalPath{selector: DeleteProjectRequest_FieldPathSelectorName}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object DeleteProjectRequest", fp)
}

func ParseDeleteProjectRequest_FieldPath(rawField string) (DeleteProjectRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeleteProjectRequest_FieldPath(fp)
}

func MustParseDeleteProjectRequest_FieldPath(rawField string) DeleteProjectRequest_FieldPath {
	fp, err := ParseDeleteProjectRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeleteProjectRequest_FieldTerminalPath struct {
	selector DeleteProjectRequest_FieldPathSelector
}

var _ DeleteProjectRequest_FieldPath = (*DeleteProjectRequest_FieldTerminalPath)(nil)

func (fp *DeleteProjectRequest_FieldTerminalPath) Selector() DeleteProjectRequest_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *DeleteProjectRequest_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *DeleteProjectRequest_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source DeleteProjectRequest
func (fp *DeleteProjectRequest_FieldTerminalPath) Get(source *DeleteProjectRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case DeleteProjectRequest_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", fp.selector))
		}
	}
	return
}

func (fp *DeleteProjectRequest_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*DeleteProjectRequest))
}

// GetSingle returns value pointed by specific field of from source DeleteProjectRequest
func (fp *DeleteProjectRequest_FieldTerminalPath) GetSingle(source *DeleteProjectRequest) (interface{}, bool) {
	switch fp.selector {
	case DeleteProjectRequest_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", fp.selector))
	}
}

func (fp *DeleteProjectRequest_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*DeleteProjectRequest))
}

// GetDefault returns a default value of the field type
func (fp *DeleteProjectRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeleteProjectRequest_FieldPathSelectorName:
		return (*project.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", fp.selector))
	}
}

func (fp *DeleteProjectRequest_FieldTerminalPath) ClearValue(item *DeleteProjectRequest) {
	if item != nil {
		switch fp.selector {
		case DeleteProjectRequest_FieldPathSelectorName:
			item.Name = nil
		default:
			panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", fp.selector))
		}
	}
}

func (fp *DeleteProjectRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*DeleteProjectRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeleteProjectRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeleteProjectRequest_FieldPathSelectorName
}

func (fp *DeleteProjectRequest_FieldTerminalPath) WithIValue(value interface{}) DeleteProjectRequest_FieldPathValue {
	switch fp.selector {
	case DeleteProjectRequest_FieldPathSelectorName:
		return &DeleteProjectRequest_FieldTerminalPathValue{DeleteProjectRequest_FieldTerminalPath: *fp, value: value.(*project.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", fp.selector))
	}
}

func (fp *DeleteProjectRequest_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *DeleteProjectRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeleteProjectRequest_FieldPathArrayOfValues {
	fpaov := &DeleteProjectRequest_FieldTerminalPathArrayOfValues{DeleteProjectRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeleteProjectRequest_FieldPathSelectorName:
		return &DeleteProjectRequest_FieldTerminalPathArrayOfValues{DeleteProjectRequest_FieldTerminalPath: *fp, values: values.([]*project.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", fp.selector))
	}
	return fpaov
}

func (fp *DeleteProjectRequest_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *DeleteProjectRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) DeleteProjectRequest_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", fp.selector))
	}
}

func (fp *DeleteProjectRequest_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// DeleteProjectRequest_FieldPathValue allows storing values for DeleteProjectRequest fields according to their type
type DeleteProjectRequest_FieldPathValue interface {
	DeleteProjectRequest_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **DeleteProjectRequest)
	CompareWith(*DeleteProjectRequest) (cmp int, comparable bool)
}

func ParseDeleteProjectRequest_FieldPathValue(pathStr, valueStr string) (DeleteProjectRequest_FieldPathValue, error) {
	fp, err := ParseDeleteProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing DeleteProjectRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeleteProjectRequest_FieldPathValue), nil
}

func MustParseDeleteProjectRequest_FieldPathValue(pathStr, valueStr string) DeleteProjectRequest_FieldPathValue {
	fpv, err := ParseDeleteProjectRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeleteProjectRequest_FieldTerminalPathValue struct {
	DeleteProjectRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteProjectRequest_FieldPathValue = (*DeleteProjectRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'DeleteProjectRequest' as interface{}
func (fpv *DeleteProjectRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeleteProjectRequest_FieldTerminalPathValue) AsNameValue() (*project.Reference, bool) {
	res, ok := fpv.value.(*project.Reference)
	return res, ok
}

// SetTo stores value for selected field for object DeleteProjectRequest
func (fpv *DeleteProjectRequest_FieldTerminalPathValue) SetTo(target **DeleteProjectRequest) {
	if *target == nil {
		*target = new(DeleteProjectRequest)
	}
	switch fpv.selector {
	case DeleteProjectRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*project.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", fpv.selector))
	}
}

func (fpv *DeleteProjectRequest_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*DeleteProjectRequest)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'DeleteProjectRequest_FieldTerminalPathValue' with the value under path in 'DeleteProjectRequest'.
func (fpv *DeleteProjectRequest_FieldTerminalPathValue) CompareWith(source *DeleteProjectRequest) (int, bool) {
	switch fpv.selector {
	case DeleteProjectRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*project.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteProjectRequest: %d", fpv.selector))
	}
}

func (fpv *DeleteProjectRequest_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*DeleteProjectRequest))
}

// DeleteProjectRequest_FieldPathArrayItemValue allows storing single item in Path-specific values for DeleteProjectRequest according to their type
// Present only for array (repeated) types.
type DeleteProjectRequest_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	DeleteProjectRequest_FieldPath
	ContainsValue(*DeleteProjectRequest) bool
}

// ParseDeleteProjectRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeleteProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) (DeleteProjectRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseDeleteProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing DeleteProjectRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeleteProjectRequest_FieldPathArrayItemValue), nil
}

func MustParseDeleteProjectRequest_FieldPathArrayItemValue(pathStr, valueStr string) DeleteProjectRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseDeleteProjectRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeleteProjectRequest_FieldTerminalPathArrayItemValue struct {
	DeleteProjectRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteProjectRequest_FieldPathArrayItemValue = (*DeleteProjectRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object DeleteProjectRequest as interface{}
func (fpaiv *DeleteProjectRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *DeleteProjectRequest_FieldTerminalPathArrayItemValue) GetSingle(source *DeleteProjectRequest) (interface{}, bool) {
	return nil, false
}

func (fpaiv *DeleteProjectRequest_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*DeleteProjectRequest))
}

// Contains returns a boolean indicating if value that is being held is present in given 'DeleteProjectRequest'
func (fpaiv *DeleteProjectRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *DeleteProjectRequest) bool {
	slice := fpaiv.DeleteProjectRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// DeleteProjectRequest_FieldPathArrayOfValues allows storing slice of values for DeleteProjectRequest fields according to their type
type DeleteProjectRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeleteProjectRequest_FieldPath
}

func ParseDeleteProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (DeleteProjectRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseDeleteProjectRequest_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing DeleteProjectRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeleteProjectRequest_FieldPathArrayOfValues), nil
}

func MustParseDeleteProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr string) DeleteProjectRequest_FieldPathArrayOfValues {
	fpaov, err := ParseDeleteProjectRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeleteProjectRequest_FieldTerminalPathArrayOfValues struct {
	DeleteProjectRequest_FieldTerminalPath
	values interface{}
}

var _ DeleteProjectRequest_FieldPathArrayOfValues = (*DeleteProjectRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeleteProjectRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeleteProjectRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*project.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeleteProjectRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*project.Reference, bool) {
	res, ok := fpaov.values.([]*project.Reference)
	return res, ok
}