condition_service.pb.fieldpath.go

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

package condition_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 (
	condition "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha/condition"
	organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha/organization"
	project "github.com/cloudwan/edgelq-sdk/iam/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"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	field_mask "google.golang.org/genproto/protobuf/field_mask"
)

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

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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &condition.Condition{}
	_ = &organization.Organization{}
	_ = &project.Project{}
	_ = &empty.Empty{}
	_ = &field_mask.FieldMask{}
	_ = &timestamp.Timestamp{}
	_ = 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 GetConditionRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() GetConditionRequest_FieldPathSelector
	Get(source *GetConditionRequest) []interface{}
	GetSingle(source *GetConditionRequest) (interface{}, bool)
	ClearValue(item *GetConditionRequest)

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

type GetConditionRequest_FieldPathSelector int32

const (
	GetConditionRequest_FieldPathSelectorName      GetConditionRequest_FieldPathSelector = 0
	GetConditionRequest_FieldPathSelectorFieldMask GetConditionRequest_FieldPathSelector = 1
	GetConditionRequest_FieldPathSelectorView      GetConditionRequest_FieldPathSelector = 2
)

func (s GetConditionRequest_FieldPathSelector) String() string {
	switch s {
	case GetConditionRequest_FieldPathSelectorName:
		return "name"
	case GetConditionRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case GetConditionRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for GetConditionRequest: %d", s))
	}
}

func BuildGetConditionRequest_FieldPath(fp gotenobject.RawFieldPath) (GetConditionRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object GetConditionRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &GetConditionRequest_FieldTerminalPath{selector: GetConditionRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &GetConditionRequest_FieldTerminalPath{selector: GetConditionRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &GetConditionRequest_FieldTerminalPath{selector: GetConditionRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object GetConditionRequest", fp)
}

func ParseGetConditionRequest_FieldPath(rawField string) (GetConditionRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildGetConditionRequest_FieldPath(fp)
}

func MustParseGetConditionRequest_FieldPath(rawField string) GetConditionRequest_FieldPath {
	fp, err := ParseGetConditionRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type GetConditionRequest_FieldTerminalPath struct {
	selector GetConditionRequest_FieldPathSelector
}

var _ GetConditionRequest_FieldPath = (*GetConditionRequest_FieldTerminalPath)(nil)

func (fp *GetConditionRequest_FieldTerminalPath) Selector() GetConditionRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *GetConditionRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case GetConditionRequest_FieldPathSelectorName:
		return (*condition.Reference)(nil)
	case GetConditionRequest_FieldPathSelectorFieldMask:
		return (*condition.Condition_FieldMask)(nil)
	case GetConditionRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for GetConditionRequest: %d", fp.selector))
	}
}

func (fp *GetConditionRequest_FieldTerminalPath) ClearValue(item *GetConditionRequest) {
	if item != nil {
		switch fp.selector {
		case GetConditionRequest_FieldPathSelectorName:
			item.Name = nil
		case GetConditionRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case GetConditionRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for GetConditionRequest: %d", fp.selector))
		}
	}
}

func (fp *GetConditionRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*GetConditionRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *GetConditionRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == GetConditionRequest_FieldPathSelectorName ||
		fp.selector == GetConditionRequest_FieldPathSelectorFieldMask ||
		fp.selector == GetConditionRequest_FieldPathSelectorView
}

func (fp *GetConditionRequest_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *GetConditionRequest_FieldTerminalPath) WithIValue(value interface{}) GetConditionRequest_FieldPathValue {
	switch fp.selector {
	case GetConditionRequest_FieldPathSelectorName:
		return &GetConditionRequest_FieldTerminalPathValue{GetConditionRequest_FieldTerminalPath: *fp, value: value.(*condition.Reference)}
	case GetConditionRequest_FieldPathSelectorFieldMask:
		return &GetConditionRequest_FieldTerminalPathValue{GetConditionRequest_FieldTerminalPath: *fp, value: value.(*condition.Condition_FieldMask)}
	case GetConditionRequest_FieldPathSelectorView:
		return &GetConditionRequest_FieldTerminalPathValue{GetConditionRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetConditionRequest: %d", fp.selector))
	}
}

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

func (fp *GetConditionRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) GetConditionRequest_FieldPathArrayOfValues {
	fpaov := &GetConditionRequest_FieldTerminalPathArrayOfValues{GetConditionRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case GetConditionRequest_FieldPathSelectorName:
		return &GetConditionRequest_FieldTerminalPathArrayOfValues{GetConditionRequest_FieldTerminalPath: *fp, values: values.([]*condition.Reference)}
	case GetConditionRequest_FieldPathSelectorFieldMask:
		return &GetConditionRequest_FieldTerminalPathArrayOfValues{GetConditionRequest_FieldTerminalPath: *fp, values: values.([]*condition.Condition_FieldMask)}
	case GetConditionRequest_FieldPathSelectorView:
		return &GetConditionRequest_FieldTerminalPathArrayOfValues{GetConditionRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetConditionRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParseGetConditionRequest_FieldPathValue(pathStr, valueStr string) (GetConditionRequest_FieldPathValue, error) {
	fp, err := ParseGetConditionRequest_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 GetConditionRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(GetConditionRequest_FieldPathValue), nil
}

func MustParseGetConditionRequest_FieldPathValue(pathStr, valueStr string) GetConditionRequest_FieldPathValue {
	fpv, err := ParseGetConditionRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type GetConditionRequest_FieldTerminalPathValue struct {
	GetConditionRequest_FieldTerminalPath
	value interface{}
}

var _ GetConditionRequest_FieldPathValue = (*GetConditionRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object GetConditionRequest
func (fpv *GetConditionRequest_FieldTerminalPathValue) SetTo(target **GetConditionRequest) {
	if *target == nil {
		*target = new(GetConditionRequest)
	}
	switch fpv.selector {
	case GetConditionRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*condition.Reference)
	case GetConditionRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*condition.Condition_FieldMask)
	case GetConditionRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for GetConditionRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'GetConditionRequest_FieldTerminalPathValue' with the value under path in 'GetConditionRequest'.
func (fpv *GetConditionRequest_FieldTerminalPathValue) CompareWith(source *GetConditionRequest) (int, bool) {
	switch fpv.selector {
	case GetConditionRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*condition.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 GetConditionRequest_FieldPathSelectorFieldMask:
		return 0, false
	case GetConditionRequest_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 GetConditionRequest: %d", fpv.selector))
	}
}

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

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

// ParseGetConditionRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseGetConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) (GetConditionRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseGetConditionRequest_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 GetConditionRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(GetConditionRequest_FieldPathArrayItemValue), nil
}

func MustParseGetConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) GetConditionRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseGetConditionRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type GetConditionRequest_FieldTerminalPathArrayItemValue struct {
	GetConditionRequest_FieldTerminalPath
	value interface{}
}

var _ GetConditionRequest_FieldPathArrayItemValue = (*GetConditionRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *GetConditionRequest_FieldTerminalPathArrayItemValue) GetSingle(source *GetConditionRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'GetConditionRequest'
func (fpaiv *GetConditionRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *GetConditionRequest) bool {
	slice := fpaiv.GetConditionRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// GetConditionRequest_FieldPathArrayOfValues allows storing slice of values for GetConditionRequest fields according to their type
type GetConditionRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	GetConditionRequest_FieldPath
}

func ParseGetConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (GetConditionRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseGetConditionRequest_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 GetConditionRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(GetConditionRequest_FieldPathArrayOfValues), nil
}

func MustParseGetConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) GetConditionRequest_FieldPathArrayOfValues {
	fpaov, err := ParseGetConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type GetConditionRequest_FieldTerminalPathArrayOfValues struct {
	GetConditionRequest_FieldTerminalPath
	values interface{}
}

var _ GetConditionRequest_FieldPathArrayOfValues = (*GetConditionRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *GetConditionRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case GetConditionRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*condition.Reference) {
			values = append(values, v)
		}
	case GetConditionRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*condition.Condition_FieldMask) {
			values = append(values, v)
		}
	case GetConditionRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *GetConditionRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*condition.Reference, bool) {
	res, ok := fpaov.values.([]*condition.Reference)
	return res, ok
}
func (fpaov *GetConditionRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*condition.Condition_FieldMask, bool) {
	res, ok := fpaov.values.([]*condition.Condition_FieldMask)
	return res, ok
}
func (fpaov *GetConditionRequest_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 BatchGetConditionsRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetConditionsRequest_FieldPathSelector
	Get(source *BatchGetConditionsRequest) []interface{}
	GetSingle(source *BatchGetConditionsRequest) (interface{}, bool)
	ClearValue(item *BatchGetConditionsRequest)

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

type BatchGetConditionsRequest_FieldPathSelector int32

const (
	BatchGetConditionsRequest_FieldPathSelectorNames     BatchGetConditionsRequest_FieldPathSelector = 0
	BatchGetConditionsRequest_FieldPathSelectorFieldMask BatchGetConditionsRequest_FieldPathSelector = 1
	BatchGetConditionsRequest_FieldPathSelectorView      BatchGetConditionsRequest_FieldPathSelector = 2
)

func (s BatchGetConditionsRequest_FieldPathSelector) String() string {
	switch s {
	case BatchGetConditionsRequest_FieldPathSelectorNames:
		return "names"
	case BatchGetConditionsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case BatchGetConditionsRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsRequest: %d", s))
	}
}

func BuildBatchGetConditionsRequest_FieldPath(fp gotenobject.RawFieldPath) (BatchGetConditionsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetConditionsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "names":
			return &BatchGetConditionsRequest_FieldTerminalPath{selector: BatchGetConditionsRequest_FieldPathSelectorNames}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &BatchGetConditionsRequest_FieldTerminalPath{selector: BatchGetConditionsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &BatchGetConditionsRequest_FieldTerminalPath{selector: BatchGetConditionsRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetConditionsRequest", fp)
}

func ParseBatchGetConditionsRequest_FieldPath(rawField string) (BatchGetConditionsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetConditionsRequest_FieldPath(fp)
}

func MustParseBatchGetConditionsRequest_FieldPath(rawField string) BatchGetConditionsRequest_FieldPath {
	fp, err := ParseBatchGetConditionsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetConditionsRequest_FieldTerminalPath struct {
	selector BatchGetConditionsRequest_FieldPathSelector
}

var _ BatchGetConditionsRequest_FieldPath = (*BatchGetConditionsRequest_FieldTerminalPath)(nil)

func (fp *BatchGetConditionsRequest_FieldTerminalPath) Selector() BatchGetConditionsRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *BatchGetConditionsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetConditionsRequest_FieldPathSelectorNames:
		return ([]*condition.Reference)(nil)
	case BatchGetConditionsRequest_FieldPathSelectorFieldMask:
		return (*condition.Condition_FieldMask)(nil)
	case BatchGetConditionsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsRequest: %d", fp.selector))
	}
}

func (fp *BatchGetConditionsRequest_FieldTerminalPath) ClearValue(item *BatchGetConditionsRequest) {
	if item != nil {
		switch fp.selector {
		case BatchGetConditionsRequest_FieldPathSelectorNames:
			item.Names = nil
		case BatchGetConditionsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case BatchGetConditionsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetConditionsRequest: %d", fp.selector))
		}
	}
}

func (fp *BatchGetConditionsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetConditionsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *BatchGetConditionsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == BatchGetConditionsRequest_FieldPathSelectorNames ||
		fp.selector == BatchGetConditionsRequest_FieldPathSelectorFieldMask ||
		fp.selector == BatchGetConditionsRequest_FieldPathSelectorView
}

func (fp *BatchGetConditionsRequest_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *BatchGetConditionsRequest_FieldTerminalPath) WithIValue(value interface{}) BatchGetConditionsRequest_FieldPathValue {
	switch fp.selector {
	case BatchGetConditionsRequest_FieldPathSelectorNames:
		return &BatchGetConditionsRequest_FieldTerminalPathValue{BatchGetConditionsRequest_FieldTerminalPath: *fp, value: value.([]*condition.Reference)}
	case BatchGetConditionsRequest_FieldPathSelectorFieldMask:
		return &BatchGetConditionsRequest_FieldTerminalPathValue{BatchGetConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.Condition_FieldMask)}
	case BatchGetConditionsRequest_FieldPathSelectorView:
		return &BatchGetConditionsRequest_FieldTerminalPathValue{BatchGetConditionsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsRequest: %d", fp.selector))
	}
}

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

func (fp *BatchGetConditionsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetConditionsRequest_FieldPathArrayOfValues {
	fpaov := &BatchGetConditionsRequest_FieldTerminalPathArrayOfValues{BatchGetConditionsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetConditionsRequest_FieldPathSelectorNames:
		return &BatchGetConditionsRequest_FieldTerminalPathArrayOfValues{BatchGetConditionsRequest_FieldTerminalPath: *fp, values: values.([][]*condition.Reference)}
	case BatchGetConditionsRequest_FieldPathSelectorFieldMask:
		return &BatchGetConditionsRequest_FieldTerminalPathArrayOfValues{BatchGetConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.Condition_FieldMask)}
	case BatchGetConditionsRequest_FieldPathSelectorView:
		return &BatchGetConditionsRequest_FieldTerminalPathArrayOfValues{BatchGetConditionsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsRequest: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetConditionsRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetConditionsRequest_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetConditionsRequest_FieldPathSelectorNames:
		return &BatchGetConditionsRequest_FieldTerminalPathArrayItemValue{BatchGetConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsRequest: %d", fp.selector))
	}
}

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

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

func ParseBatchGetConditionsRequest_FieldPathValue(pathStr, valueStr string) (BatchGetConditionsRequest_FieldPathValue, error) {
	fp, err := ParseBatchGetConditionsRequest_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 BatchGetConditionsRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(BatchGetConditionsRequest_FieldPathValue), nil
}

func MustParseBatchGetConditionsRequest_FieldPathValue(pathStr, valueStr string) BatchGetConditionsRequest_FieldPathValue {
	fpv, err := ParseBatchGetConditionsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetConditionsRequest_FieldTerminalPathValue struct {
	BatchGetConditionsRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetConditionsRequest_FieldPathValue = (*BatchGetConditionsRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object BatchGetConditionsRequest
func (fpv *BatchGetConditionsRequest_FieldTerminalPathValue) SetTo(target **BatchGetConditionsRequest) {
	if *target == nil {
		*target = new(BatchGetConditionsRequest)
	}
	switch fpv.selector {
	case BatchGetConditionsRequest_FieldPathSelectorNames:
		(*target).Names = fpv.value.([]*condition.Reference)
	case BatchGetConditionsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*condition.Condition_FieldMask)
	case BatchGetConditionsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'BatchGetConditionsRequest_FieldTerminalPathValue' with the value under path in 'BatchGetConditionsRequest'.
func (fpv *BatchGetConditionsRequest_FieldTerminalPathValue) CompareWith(source *BatchGetConditionsRequest) (int, bool) {
	switch fpv.selector {
	case BatchGetConditionsRequest_FieldPathSelectorNames:
		return 0, false
	case BatchGetConditionsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case BatchGetConditionsRequest_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 BatchGetConditionsRequest: %d", fpv.selector))
	}
}

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

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

// ParseBatchGetConditionsRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseBatchGetConditionsRequest_FieldPathArrayItemValue(pathStr, valueStr string) (BatchGetConditionsRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseBatchGetConditionsRequest_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 BatchGetConditionsRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(BatchGetConditionsRequest_FieldPathArrayItemValue), nil
}

func MustParseBatchGetConditionsRequest_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetConditionsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetConditionsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetConditionsRequest_FieldTerminalPathArrayItemValue struct {
	BatchGetConditionsRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetConditionsRequest_FieldPathArrayItemValue = (*BatchGetConditionsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *BatchGetConditionsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetConditionsRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'BatchGetConditionsRequest'
func (fpaiv *BatchGetConditionsRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *BatchGetConditionsRequest) bool {
	slice := fpaiv.BatchGetConditionsRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// BatchGetConditionsRequest_FieldPathArrayOfValues allows storing slice of values for BatchGetConditionsRequest fields according to their type
type BatchGetConditionsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetConditionsRequest_FieldPath
}

func ParseBatchGetConditionsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (BatchGetConditionsRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseBatchGetConditionsRequest_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 BatchGetConditionsRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(BatchGetConditionsRequest_FieldPathArrayOfValues), nil
}

func MustParseBatchGetConditionsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetConditionsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetConditionsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetConditionsRequest_FieldTerminalPathArrayOfValues struct {
	BatchGetConditionsRequest_FieldTerminalPath
	values interface{}
}

var _ BatchGetConditionsRequest_FieldPathArrayOfValues = (*BatchGetConditionsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetConditionsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetConditionsRequest_FieldPathSelectorNames:
		for _, v := range fpaov.values.([][]*condition.Reference) {
			values = append(values, v)
		}
	case BatchGetConditionsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*condition.Condition_FieldMask) {
			values = append(values, v)
		}
	case BatchGetConditionsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetConditionsRequest_FieldTerminalPathArrayOfValues) AsNamesArrayOfValues() ([][]*condition.Reference, bool) {
	res, ok := fpaov.values.([][]*condition.Reference)
	return res, ok
}
func (fpaov *BatchGetConditionsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*condition.Condition_FieldMask, bool) {
	res, ok := fpaov.values.([]*condition.Condition_FieldMask)
	return res, ok
}
func (fpaov *BatchGetConditionsRequest_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 BatchGetConditionsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetConditionsResponse_FieldPathSelector
	Get(source *BatchGetConditionsResponse) []interface{}
	GetSingle(source *BatchGetConditionsResponse) (interface{}, bool)
	ClearValue(item *BatchGetConditionsResponse)

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

type BatchGetConditionsResponse_FieldPathSelector int32

const (
	BatchGetConditionsResponse_FieldPathSelectorConditions BatchGetConditionsResponse_FieldPathSelector = 0
	BatchGetConditionsResponse_FieldPathSelectorMissing    BatchGetConditionsResponse_FieldPathSelector = 1
)

func (s BatchGetConditionsResponse_FieldPathSelector) String() string {
	switch s {
	case BatchGetConditionsResponse_FieldPathSelectorConditions:
		return "conditions"
	case BatchGetConditionsResponse_FieldPathSelectorMissing:
		return "missing"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsResponse: %d", s))
	}
}

func BuildBatchGetConditionsResponse_FieldPath(fp gotenobject.RawFieldPath) (BatchGetConditionsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetConditionsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conditions":
			return &BatchGetConditionsResponse_FieldTerminalPath{selector: BatchGetConditionsResponse_FieldPathSelectorConditions}, nil
		case "missing":
			return &BatchGetConditionsResponse_FieldTerminalPath{selector: BatchGetConditionsResponse_FieldPathSelectorMissing}, nil
		}
	} else {
		switch fp[0] {
		case "conditions":
			if subpath, err := condition.BuildCondition_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &BatchGetConditionsResponse_FieldSubPath{selector: BatchGetConditionsResponse_FieldPathSelectorConditions, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetConditionsResponse", fp)
}

func ParseBatchGetConditionsResponse_FieldPath(rawField string) (BatchGetConditionsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetConditionsResponse_FieldPath(fp)
}

func MustParseBatchGetConditionsResponse_FieldPath(rawField string) BatchGetConditionsResponse_FieldPath {
	fp, err := ParseBatchGetConditionsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetConditionsResponse_FieldTerminalPath struct {
	selector BatchGetConditionsResponse_FieldPathSelector
}

var _ BatchGetConditionsResponse_FieldPath = (*BatchGetConditionsResponse_FieldTerminalPath)(nil)

func (fp *BatchGetConditionsResponse_FieldTerminalPath) Selector() BatchGetConditionsResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *BatchGetConditionsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetConditionsResponse_FieldPathSelectorConditions:
		return ([]*condition.Condition)(nil)
	case BatchGetConditionsResponse_FieldPathSelectorMissing:
		return ([]*condition.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsResponse: %d", fp.selector))
	}
}

func (fp *BatchGetConditionsResponse_FieldTerminalPath) ClearValue(item *BatchGetConditionsResponse) {
	if item != nil {
		switch fp.selector {
		case BatchGetConditionsResponse_FieldPathSelectorConditions:
			item.Conditions = nil
		case BatchGetConditionsResponse_FieldPathSelectorMissing:
			item.Missing = nil
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetConditionsResponse: %d", fp.selector))
		}
	}
}

func (fp *BatchGetConditionsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetConditionsResponse))
}

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

func (fp *BatchGetConditionsResponse_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *BatchGetConditionsResponse_FieldTerminalPath) WithIValue(value interface{}) BatchGetConditionsResponse_FieldPathValue {
	switch fp.selector {
	case BatchGetConditionsResponse_FieldPathSelectorConditions:
		return &BatchGetConditionsResponse_FieldTerminalPathValue{BatchGetConditionsResponse_FieldTerminalPath: *fp, value: value.([]*condition.Condition)}
	case BatchGetConditionsResponse_FieldPathSelectorMissing:
		return &BatchGetConditionsResponse_FieldTerminalPathValue{BatchGetConditionsResponse_FieldTerminalPath: *fp, value: value.([]*condition.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsResponse: %d", fp.selector))
	}
}

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

func (fp *BatchGetConditionsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetConditionsResponse_FieldPathArrayOfValues {
	fpaov := &BatchGetConditionsResponse_FieldTerminalPathArrayOfValues{BatchGetConditionsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetConditionsResponse_FieldPathSelectorConditions:
		return &BatchGetConditionsResponse_FieldTerminalPathArrayOfValues{BatchGetConditionsResponse_FieldTerminalPath: *fp, values: values.([][]*condition.Condition)}
	case BatchGetConditionsResponse_FieldPathSelectorMissing:
		return &BatchGetConditionsResponse_FieldTerminalPathArrayOfValues{BatchGetConditionsResponse_FieldTerminalPath: *fp, values: values.([][]*condition.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetConditionsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetConditionsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetConditionsResponse_FieldPathSelectorConditions:
		return &BatchGetConditionsResponse_FieldTerminalPathArrayItemValue{BatchGetConditionsResponse_FieldTerminalPath: *fp, value: value.(*condition.Condition)}
	case BatchGetConditionsResponse_FieldPathSelectorMissing:
		return &BatchGetConditionsResponse_FieldTerminalPathArrayItemValue{BatchGetConditionsResponse_FieldTerminalPath: *fp, value: value.(*condition.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsResponse: %d", fp.selector))
	}
}

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

type BatchGetConditionsResponse_FieldSubPath struct {
	selector BatchGetConditionsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ BatchGetConditionsResponse_FieldPath = (*BatchGetConditionsResponse_FieldSubPath)(nil)

func (fps *BatchGetConditionsResponse_FieldSubPath) Selector() BatchGetConditionsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *BatchGetConditionsResponse_FieldSubPath) AsConditionsSubPath() (condition.Condition_FieldPath, bool) {
	res, ok := fps.subPath.(condition.Condition_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source BatchGetConditionsResponse
func (fps *BatchGetConditionsResponse_FieldSubPath) Get(source *BatchGetConditionsResponse) (values []interface{}) {
	switch fps.selector {
	case BatchGetConditionsResponse_FieldPathSelectorConditions:
		for _, item := range source.GetConditions() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsResponse: %d", fps.selector))
	}
	return
}

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

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

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

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

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

func (fps *BatchGetConditionsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*BatchGetConditionsResponse))
}

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

func (fps *BatchGetConditionsResponse_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&BatchGetConditionsResponse_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *BatchGetConditionsResponse_FieldSubPath) WithIValue(value interface{}) BatchGetConditionsResponse_FieldPathValue {
	return &BatchGetConditionsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *BatchGetConditionsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) BatchGetConditionsResponse_FieldPathArrayOfValues {
	return &BatchGetConditionsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *BatchGetConditionsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) BatchGetConditionsResponse_FieldPathArrayItemValue {
	return &BatchGetConditionsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParseBatchGetConditionsResponse_FieldPathValue(pathStr, valueStr string) (BatchGetConditionsResponse_FieldPathValue, error) {
	fp, err := ParseBatchGetConditionsResponse_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 BatchGetConditionsResponse field path value from %s: %v", valueStr, err)
	}
	return fpv.(BatchGetConditionsResponse_FieldPathValue), nil
}

func MustParseBatchGetConditionsResponse_FieldPathValue(pathStr, valueStr string) BatchGetConditionsResponse_FieldPathValue {
	fpv, err := ParseBatchGetConditionsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetConditionsResponse_FieldTerminalPathValue struct {
	BatchGetConditionsResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetConditionsResponse_FieldPathValue = (*BatchGetConditionsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetConditionsResponse' as interface{}
func (fpv *BatchGetConditionsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetConditionsResponse_FieldTerminalPathValue) AsConditionsValue() ([]*condition.Condition, bool) {
	res, ok := fpv.value.([]*condition.Condition)
	return res, ok
}
func (fpv *BatchGetConditionsResponse_FieldTerminalPathValue) AsMissingValue() ([]*condition.Reference, bool) {
	res, ok := fpv.value.([]*condition.Reference)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetConditionsResponse
func (fpv *BatchGetConditionsResponse_FieldTerminalPathValue) SetTo(target **BatchGetConditionsResponse) {
	if *target == nil {
		*target = new(BatchGetConditionsResponse)
	}
	switch fpv.selector {
	case BatchGetConditionsResponse_FieldPathSelectorConditions:
		(*target).Conditions = fpv.value.([]*condition.Condition)
	case BatchGetConditionsResponse_FieldPathSelectorMissing:
		(*target).Missing = fpv.value.([]*condition.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConditionsResponse: %d", fpv.selector))
	}
}

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

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

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

type BatchGetConditionsResponse_FieldSubPathValue struct {
	BatchGetConditionsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ BatchGetConditionsResponse_FieldPathValue = (*BatchGetConditionsResponse_FieldSubPathValue)(nil)

func (fpvs *BatchGetConditionsResponse_FieldSubPathValue) AsConditionsPathValue() (condition.Condition_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(condition.Condition_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

// ParseBatchGetConditionsResponse_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseBatchGetConditionsResponse_FieldPathArrayItemValue(pathStr, valueStr string) (BatchGetConditionsResponse_FieldPathArrayItemValue, error) {
	fp, err := ParseBatchGetConditionsResponse_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 BatchGetConditionsResponse field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(BatchGetConditionsResponse_FieldPathArrayItemValue), nil
}

func MustParseBatchGetConditionsResponse_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetConditionsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetConditionsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetConditionsResponse_FieldTerminalPathArrayItemValue struct {
	BatchGetConditionsResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetConditionsResponse_FieldPathArrayItemValue = (*BatchGetConditionsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetConditionsResponse as interface{}
func (fpaiv *BatchGetConditionsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetConditionsResponse_FieldTerminalPathArrayItemValue) AsConditionsItemValue() (*condition.Condition, bool) {
	res, ok := fpaiv.value.(*condition.Condition)
	return res, ok
}
func (fpaiv *BatchGetConditionsResponse_FieldTerminalPathArrayItemValue) AsMissingItemValue() (*condition.Reference, bool) {
	res, ok := fpaiv.value.(*condition.Reference)
	return res, ok
}

func (fpaiv *BatchGetConditionsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetConditionsResponse) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'BatchGetConditionsResponse'
func (fpaiv *BatchGetConditionsResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *BatchGetConditionsResponse) bool {
	slice := fpaiv.BatchGetConditionsResponse_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type BatchGetConditionsResponse_FieldSubPathArrayItemValue struct {
	BatchGetConditionsResponse_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *BatchGetConditionsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *BatchGetConditionsResponse_FieldSubPathArrayItemValue) AsConditionsPathItemValue() (condition.Condition_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(condition.Condition_FieldPathArrayItemValue)
	return res, ok
}

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

// BatchGetConditionsResponse_FieldPathArrayOfValues allows storing slice of values for BatchGetConditionsResponse fields according to their type
type BatchGetConditionsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetConditionsResponse_FieldPath
}

func ParseBatchGetConditionsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) (BatchGetConditionsResponse_FieldPathArrayOfValues, error) {
	fp, err := ParseBatchGetConditionsResponse_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 BatchGetConditionsResponse field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(BatchGetConditionsResponse_FieldPathArrayOfValues), nil
}

func MustParseBatchGetConditionsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetConditionsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetConditionsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetConditionsResponse_FieldTerminalPathArrayOfValues struct {
	BatchGetConditionsResponse_FieldTerminalPath
	values interface{}
}

var _ BatchGetConditionsResponse_FieldPathArrayOfValues = (*BatchGetConditionsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetConditionsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetConditionsResponse_FieldPathSelectorConditions:
		for _, v := range fpaov.values.([][]*condition.Condition) {
			values = append(values, v)
		}
	case BatchGetConditionsResponse_FieldPathSelectorMissing:
		for _, v := range fpaov.values.([][]*condition.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetConditionsResponse_FieldTerminalPathArrayOfValues) AsConditionsArrayOfValues() ([][]*condition.Condition, bool) {
	res, ok := fpaov.values.([][]*condition.Condition)
	return res, ok
}
func (fpaov *BatchGetConditionsResponse_FieldTerminalPathArrayOfValues) AsMissingArrayOfValues() ([][]*condition.Reference, bool) {
	res, ok := fpaov.values.([][]*condition.Reference)
	return res, ok
}

type BatchGetConditionsResponse_FieldSubPathArrayOfValues struct {
	BatchGetConditionsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ BatchGetConditionsResponse_FieldPathArrayOfValues = (*BatchGetConditionsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *BatchGetConditionsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *BatchGetConditionsResponse_FieldSubPathArrayOfValues) AsConditionsPathArrayOfValues() (condition.Condition_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(condition.Condition_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ListConditionsRequest_FieldPathSelector int32

const (
	ListConditionsRequest_FieldPathSelectorParent            ListConditionsRequest_FieldPathSelector = 0
	ListConditionsRequest_FieldPathSelectorPageSize          ListConditionsRequest_FieldPathSelector = 1
	ListConditionsRequest_FieldPathSelectorPageToken         ListConditionsRequest_FieldPathSelector = 2
	ListConditionsRequest_FieldPathSelectorOrderBy           ListConditionsRequest_FieldPathSelector = 3
	ListConditionsRequest_FieldPathSelectorFilter            ListConditionsRequest_FieldPathSelector = 4
	ListConditionsRequest_FieldPathSelectorFieldMask         ListConditionsRequest_FieldPathSelector = 5
	ListConditionsRequest_FieldPathSelectorView              ListConditionsRequest_FieldPathSelector = 6
	ListConditionsRequest_FieldPathSelectorIncludePagingInfo ListConditionsRequest_FieldPathSelector = 7
)

func (s ListConditionsRequest_FieldPathSelector) String() string {
	switch s {
	case ListConditionsRequest_FieldPathSelectorParent:
		return "parent"
	case ListConditionsRequest_FieldPathSelectorPageSize:
		return "page_size"
	case ListConditionsRequest_FieldPathSelectorPageToken:
		return "page_token"
	case ListConditionsRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case ListConditionsRequest_FieldPathSelectorFilter:
		return "filter"
	case ListConditionsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case ListConditionsRequest_FieldPathSelectorView:
		return "view"
	case ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
		return "include_paging_info"
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsRequest: %d", s))
	}
}

func BuildListConditionsRequest_FieldPath(fp gotenobject.RawFieldPath) (ListConditionsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListConditionsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &ListConditionsRequest_FieldTerminalPath{selector: ListConditionsRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &ListConditionsRequest_FieldTerminalPath{selector: ListConditionsRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &ListConditionsRequest_FieldTerminalPath{selector: ListConditionsRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &ListConditionsRequest_FieldTerminalPath{selector: ListConditionsRequest_FieldPathSelectorOrderBy}, nil
		case "filter":
			return &ListConditionsRequest_FieldTerminalPath{selector: ListConditionsRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &ListConditionsRequest_FieldTerminalPath{selector: ListConditionsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &ListConditionsRequest_FieldTerminalPath{selector: ListConditionsRequest_FieldPathSelectorView}, nil
		case "include_paging_info", "includePagingInfo", "include-paging-info":
			return &ListConditionsRequest_FieldTerminalPath{selector: ListConditionsRequest_FieldPathSelectorIncludePagingInfo}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListConditionsRequest", fp)
}

func ParseListConditionsRequest_FieldPath(rawField string) (ListConditionsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListConditionsRequest_FieldPath(fp)
}

func MustParseListConditionsRequest_FieldPath(rawField string) ListConditionsRequest_FieldPath {
	fp, err := ParseListConditionsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListConditionsRequest_FieldTerminalPath struct {
	selector ListConditionsRequest_FieldPathSelector
}

var _ ListConditionsRequest_FieldPath = (*ListConditionsRequest_FieldTerminalPath)(nil)

func (fp *ListConditionsRequest_FieldTerminalPath) Selector() ListConditionsRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListConditionsRequest
func (fp *ListConditionsRequest_FieldTerminalPath) Get(source *ListConditionsRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListConditionsRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case ListConditionsRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case ListConditionsRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case ListConditionsRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case ListConditionsRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case ListConditionsRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case ListConditionsRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
			values = append(values, source.IncludePagingInfo)
		default:
			panic(fmt.Sprintf("Invalid selector for ListConditionsRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListConditionsRequest
func (fp *ListConditionsRequest_FieldTerminalPath) GetSingle(source *ListConditionsRequest) (interface{}, bool) {
	switch fp.selector {
	case ListConditionsRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case ListConditionsRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case ListConditionsRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case ListConditionsRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case ListConditionsRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case ListConditionsRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case ListConditionsRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
		return source.GetIncludePagingInfo(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListConditionsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListConditionsRequest_FieldPathSelectorParent:
		return (*condition.ParentName)(nil)
	case ListConditionsRequest_FieldPathSelectorPageSize:
		return int32(0)
	case ListConditionsRequest_FieldPathSelectorPageToken:
		return (*condition.PagerCursor)(nil)
	case ListConditionsRequest_FieldPathSelectorOrderBy:
		return (*condition.OrderBy)(nil)
	case ListConditionsRequest_FieldPathSelectorFilter:
		return (*condition.Filter)(nil)
	case ListConditionsRequest_FieldPathSelectorFieldMask:
		return (*condition.Condition_FieldMask)(nil)
	case ListConditionsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsRequest: %d", fp.selector))
	}
}

func (fp *ListConditionsRequest_FieldTerminalPath) ClearValue(item *ListConditionsRequest) {
	if item != nil {
		switch fp.selector {
		case ListConditionsRequest_FieldPathSelectorParent:
			item.Parent = nil
		case ListConditionsRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case ListConditionsRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case ListConditionsRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case ListConditionsRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case ListConditionsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case ListConditionsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
			item.IncludePagingInfo = false
		default:
			panic(fmt.Sprintf("Invalid selector for ListConditionsRequest: %d", fp.selector))
		}
	}
}

func (fp *ListConditionsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListConditionsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListConditionsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListConditionsRequest_FieldPathSelectorParent ||
		fp.selector == ListConditionsRequest_FieldPathSelectorPageSize ||
		fp.selector == ListConditionsRequest_FieldPathSelectorPageToken ||
		fp.selector == ListConditionsRequest_FieldPathSelectorOrderBy ||
		fp.selector == ListConditionsRequest_FieldPathSelectorFilter ||
		fp.selector == ListConditionsRequest_FieldPathSelectorFieldMask ||
		fp.selector == ListConditionsRequest_FieldPathSelectorView ||
		fp.selector == ListConditionsRequest_FieldPathSelectorIncludePagingInfo
}

func (fp *ListConditionsRequest_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ListConditionsRequest_FieldTerminalPath) WithIValue(value interface{}) ListConditionsRequest_FieldPathValue {
	switch fp.selector {
	case ListConditionsRequest_FieldPathSelectorParent:
		return &ListConditionsRequest_FieldTerminalPathValue{ListConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.ParentName)}
	case ListConditionsRequest_FieldPathSelectorPageSize:
		return &ListConditionsRequest_FieldTerminalPathValue{ListConditionsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case ListConditionsRequest_FieldPathSelectorPageToken:
		return &ListConditionsRequest_FieldTerminalPathValue{ListConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.PagerCursor)}
	case ListConditionsRequest_FieldPathSelectorOrderBy:
		return &ListConditionsRequest_FieldTerminalPathValue{ListConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.OrderBy)}
	case ListConditionsRequest_FieldPathSelectorFilter:
		return &ListConditionsRequest_FieldTerminalPathValue{ListConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.Filter)}
	case ListConditionsRequest_FieldPathSelectorFieldMask:
		return &ListConditionsRequest_FieldTerminalPathValue{ListConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.Condition_FieldMask)}
	case ListConditionsRequest_FieldPathSelectorView:
		return &ListConditionsRequest_FieldTerminalPathValue{ListConditionsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
		return &ListConditionsRequest_FieldTerminalPathValue{ListConditionsRequest_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsRequest: %d", fp.selector))
	}
}

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

func (fp *ListConditionsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListConditionsRequest_FieldPathArrayOfValues {
	fpaov := &ListConditionsRequest_FieldTerminalPathArrayOfValues{ListConditionsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListConditionsRequest_FieldPathSelectorParent:
		return &ListConditionsRequest_FieldTerminalPathArrayOfValues{ListConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.ParentName)}
	case ListConditionsRequest_FieldPathSelectorPageSize:
		return &ListConditionsRequest_FieldTerminalPathArrayOfValues{ListConditionsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListConditionsRequest_FieldPathSelectorPageToken:
		return &ListConditionsRequest_FieldTerminalPathArrayOfValues{ListConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.PagerCursor)}
	case ListConditionsRequest_FieldPathSelectorOrderBy:
		return &ListConditionsRequest_FieldTerminalPathArrayOfValues{ListConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.OrderBy)}
	case ListConditionsRequest_FieldPathSelectorFilter:
		return &ListConditionsRequest_FieldTerminalPathArrayOfValues{ListConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.Filter)}
	case ListConditionsRequest_FieldPathSelectorFieldMask:
		return &ListConditionsRequest_FieldTerminalPathArrayOfValues{ListConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.Condition_FieldMask)}
	case ListConditionsRequest_FieldPathSelectorView:
		return &ListConditionsRequest_FieldTerminalPathArrayOfValues{ListConditionsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
		return &ListConditionsRequest_FieldTerminalPathArrayOfValues{ListConditionsRequest_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParseListConditionsRequest_FieldPathValue(pathStr, valueStr string) (ListConditionsRequest_FieldPathValue, error) {
	fp, err := ParseListConditionsRequest_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 ListConditionsRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(ListConditionsRequest_FieldPathValue), nil
}

func MustParseListConditionsRequest_FieldPathValue(pathStr, valueStr string) ListConditionsRequest_FieldPathValue {
	fpv, err := ParseListConditionsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListConditionsRequest_FieldTerminalPathValue struct {
	ListConditionsRequest_FieldTerminalPath
	value interface{}
}

var _ ListConditionsRequest_FieldPathValue = (*ListConditionsRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListConditionsRequest' as interface{}
func (fpv *ListConditionsRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListConditionsRequest_FieldTerminalPathValue) AsParentValue() (*condition.ParentName, bool) {
	res, ok := fpv.value.(*condition.ParentName)
	return res, ok
}
func (fpv *ListConditionsRequest_FieldTerminalPathValue) AsPageSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListConditionsRequest_FieldTerminalPathValue) AsPageTokenValue() (*condition.PagerCursor, bool) {
	res, ok := fpv.value.(*condition.PagerCursor)
	return res, ok
}
func (fpv *ListConditionsRequest_FieldTerminalPathValue) AsOrderByValue() (*condition.OrderBy, bool) {
	res, ok := fpv.value.(*condition.OrderBy)
	return res, ok
}
func (fpv *ListConditionsRequest_FieldTerminalPathValue) AsFilterValue() (*condition.Filter, bool) {
	res, ok := fpv.value.(*condition.Filter)
	return res, ok
}
func (fpv *ListConditionsRequest_FieldTerminalPathValue) AsFieldMaskValue() (*condition.Condition_FieldMask, bool) {
	res, ok := fpv.value.(*condition.Condition_FieldMask)
	return res, ok
}
func (fpv *ListConditionsRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}
func (fpv *ListConditionsRequest_FieldTerminalPathValue) AsIncludePagingInfoValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object ListConditionsRequest
func (fpv *ListConditionsRequest_FieldTerminalPathValue) SetTo(target **ListConditionsRequest) {
	if *target == nil {
		*target = new(ListConditionsRequest)
	}
	switch fpv.selector {
	case ListConditionsRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*condition.ParentName)
	case ListConditionsRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case ListConditionsRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*condition.PagerCursor)
	case ListConditionsRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*condition.OrderBy)
	case ListConditionsRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*condition.Filter)
	case ListConditionsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*condition.Condition_FieldMask)
	case ListConditionsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
		(*target).IncludePagingInfo = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListConditionsRequest_FieldTerminalPathValue' with the value under path in 'ListConditionsRequest'.
func (fpv *ListConditionsRequest_FieldTerminalPathValue) CompareWith(source *ListConditionsRequest) (int, bool) {
	switch fpv.selector {
	case ListConditionsRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*condition.ParentName)
		rightValue := source.GetParent()
		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 ListConditionsRequest_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 ListConditionsRequest_FieldPathSelectorPageToken:
		return 0, false
	case ListConditionsRequest_FieldPathSelectorOrderBy:
		return 0, false
	case ListConditionsRequest_FieldPathSelectorFilter:
		return 0, false
	case ListConditionsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case ListConditionsRequest_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 ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIncludePagingInfo()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsRequest: %d", fpv.selector))
	}
}

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

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

// ParseListConditionsRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseListConditionsRequest_FieldPathArrayItemValue(pathStr, valueStr string) (ListConditionsRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseListConditionsRequest_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 ListConditionsRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ListConditionsRequest_FieldPathArrayItemValue), nil
}

func MustParseListConditionsRequest_FieldPathArrayItemValue(pathStr, valueStr string) ListConditionsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseListConditionsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListConditionsRequest_FieldTerminalPathArrayItemValue struct {
	ListConditionsRequest_FieldTerminalPath
	value interface{}
}

var _ ListConditionsRequest_FieldPathArrayItemValue = (*ListConditionsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ListConditionsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ListConditionsRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ListConditionsRequest'
func (fpaiv *ListConditionsRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *ListConditionsRequest) bool {
	slice := fpaiv.ListConditionsRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// ListConditionsRequest_FieldPathArrayOfValues allows storing slice of values for ListConditionsRequest fields according to their type
type ListConditionsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListConditionsRequest_FieldPath
}

func ParseListConditionsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (ListConditionsRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseListConditionsRequest_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 ListConditionsRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ListConditionsRequest_FieldPathArrayOfValues), nil
}

func MustParseListConditionsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ListConditionsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseListConditionsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListConditionsRequest_FieldTerminalPathArrayOfValues struct {
	ListConditionsRequest_FieldTerminalPath
	values interface{}
}

var _ ListConditionsRequest_FieldPathArrayOfValues = (*ListConditionsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListConditionsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListConditionsRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*condition.ParentName) {
			values = append(values, v)
		}
	case ListConditionsRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListConditionsRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*condition.PagerCursor) {
			values = append(values, v)
		}
	case ListConditionsRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*condition.OrderBy) {
			values = append(values, v)
		}
	case ListConditionsRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*condition.Filter) {
			values = append(values, v)
		}
	case ListConditionsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*condition.Condition_FieldMask) {
			values = append(values, v)
		}
	case ListConditionsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case ListConditionsRequest_FieldPathSelectorIncludePagingInfo:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListConditionsRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*condition.ParentName, bool) {
	res, ok := fpaov.values.([]*condition.ParentName)
	return res, ok
}
func (fpaov *ListConditionsRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListConditionsRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*condition.PagerCursor, bool) {
	res, ok := fpaov.values.([]*condition.PagerCursor)
	return res, ok
}
func (fpaov *ListConditionsRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*condition.OrderBy, bool) {
	res, ok := fpaov.values.([]*condition.OrderBy)
	return res, ok
}
func (fpaov *ListConditionsRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*condition.Filter, bool) {
	res, ok := fpaov.values.([]*condition.Filter)
	return res, ok
}
func (fpaov *ListConditionsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*condition.Condition_FieldMask, bool) {
	res, ok := fpaov.values.([]*condition.Condition_FieldMask)
	return res, ok
}
func (fpaov *ListConditionsRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *ListConditionsRequest_FieldTerminalPathArrayOfValues) AsIncludePagingInfoArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

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

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

type ListConditionsResponse_FieldPathSelector int32

const (
	ListConditionsResponse_FieldPathSelectorConditions        ListConditionsResponse_FieldPathSelector = 0
	ListConditionsResponse_FieldPathSelectorPrevPageToken     ListConditionsResponse_FieldPathSelector = 1
	ListConditionsResponse_FieldPathSelectorNextPageToken     ListConditionsResponse_FieldPathSelector = 2
	ListConditionsResponse_FieldPathSelectorCurrentOffset     ListConditionsResponse_FieldPathSelector = 3
	ListConditionsResponse_FieldPathSelectorTotalResultsCount ListConditionsResponse_FieldPathSelector = 4
)

func (s ListConditionsResponse_FieldPathSelector) String() string {
	switch s {
	case ListConditionsResponse_FieldPathSelectorConditions:
		return "conditions"
	case ListConditionsResponse_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case ListConditionsResponse_FieldPathSelectorNextPageToken:
		return "next_page_token"
	case ListConditionsResponse_FieldPathSelectorCurrentOffset:
		return "current_offset"
	case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
		return "total_results_count"
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", s))
	}
}

func BuildListConditionsResponse_FieldPath(fp gotenobject.RawFieldPath) (ListConditionsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListConditionsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conditions":
			return &ListConditionsResponse_FieldTerminalPath{selector: ListConditionsResponse_FieldPathSelectorConditions}, nil
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &ListConditionsResponse_FieldTerminalPath{selector: ListConditionsResponse_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &ListConditionsResponse_FieldTerminalPath{selector: ListConditionsResponse_FieldPathSelectorNextPageToken}, nil
		case "current_offset", "currentOffset", "current-offset":
			return &ListConditionsResponse_FieldTerminalPath{selector: ListConditionsResponse_FieldPathSelectorCurrentOffset}, nil
		case "total_results_count", "totalResultsCount", "total-results-count":
			return &ListConditionsResponse_FieldTerminalPath{selector: ListConditionsResponse_FieldPathSelectorTotalResultsCount}, nil
		}
	} else {
		switch fp[0] {
		case "conditions":
			if subpath, err := condition.BuildCondition_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListConditionsResponse_FieldSubPath{selector: ListConditionsResponse_FieldPathSelectorConditions, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListConditionsResponse", fp)
}

func ParseListConditionsResponse_FieldPath(rawField string) (ListConditionsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListConditionsResponse_FieldPath(fp)
}

func MustParseListConditionsResponse_FieldPath(rawField string) ListConditionsResponse_FieldPath {
	fp, err := ParseListConditionsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListConditionsResponse_FieldTerminalPath struct {
	selector ListConditionsResponse_FieldPathSelector
}

var _ ListConditionsResponse_FieldPath = (*ListConditionsResponse_FieldTerminalPath)(nil)

func (fp *ListConditionsResponse_FieldTerminalPath) Selector() ListConditionsResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListConditionsResponse
func (fp *ListConditionsResponse_FieldTerminalPath) Get(source *ListConditionsResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListConditionsResponse_FieldPathSelectorConditions:
			for _, value := range source.GetConditions() {
				values = append(values, value)
			}
		case ListConditionsResponse_FieldPathSelectorPrevPageToken:
			if source.PrevPageToken != nil {
				values = append(values, source.PrevPageToken)
			}
		case ListConditionsResponse_FieldPathSelectorNextPageToken:
			if source.NextPageToken != nil {
				values = append(values, source.NextPageToken)
			}
		case ListConditionsResponse_FieldPathSelectorCurrentOffset:
			values = append(values, source.CurrentOffset)
		case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
			values = append(values, source.TotalResultsCount)
		default:
			panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListConditionsResponse
func (fp *ListConditionsResponse_FieldTerminalPath) GetSingle(source *ListConditionsResponse) (interface{}, bool) {
	switch fp.selector {
	case ListConditionsResponse_FieldPathSelectorConditions:
		res := source.GetConditions()
		return res, res != nil
	case ListConditionsResponse_FieldPathSelectorPrevPageToken:
		res := source.GetPrevPageToken()
		return res, res != nil
	case ListConditionsResponse_FieldPathSelectorNextPageToken:
		res := source.GetNextPageToken()
		return res, res != nil
	case ListConditionsResponse_FieldPathSelectorCurrentOffset:
		return source.GetCurrentOffset(), source != nil
	case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
		return source.GetTotalResultsCount(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListConditionsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListConditionsResponse_FieldPathSelectorConditions:
		return ([]*condition.Condition)(nil)
	case ListConditionsResponse_FieldPathSelectorPrevPageToken:
		return (*condition.PagerCursor)(nil)
	case ListConditionsResponse_FieldPathSelectorNextPageToken:
		return (*condition.PagerCursor)(nil)
	case ListConditionsResponse_FieldPathSelectorCurrentOffset:
		return int32(0)
	case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fp.selector))
	}
}

func (fp *ListConditionsResponse_FieldTerminalPath) ClearValue(item *ListConditionsResponse) {
	if item != nil {
		switch fp.selector {
		case ListConditionsResponse_FieldPathSelectorConditions:
			item.Conditions = nil
		case ListConditionsResponse_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case ListConditionsResponse_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		case ListConditionsResponse_FieldPathSelectorCurrentOffset:
			item.CurrentOffset = int32(0)
		case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
			item.TotalResultsCount = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fp.selector))
		}
	}
}

func (fp *ListConditionsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListConditionsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListConditionsResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListConditionsResponse_FieldPathSelectorPrevPageToken ||
		fp.selector == ListConditionsResponse_FieldPathSelectorNextPageToken ||
		fp.selector == ListConditionsResponse_FieldPathSelectorCurrentOffset ||
		fp.selector == ListConditionsResponse_FieldPathSelectorTotalResultsCount
}

func (fp *ListConditionsResponse_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ListConditionsResponse_FieldTerminalPath) WithIValue(value interface{}) ListConditionsResponse_FieldPathValue {
	switch fp.selector {
	case ListConditionsResponse_FieldPathSelectorConditions:
		return &ListConditionsResponse_FieldTerminalPathValue{ListConditionsResponse_FieldTerminalPath: *fp, value: value.([]*condition.Condition)}
	case ListConditionsResponse_FieldPathSelectorPrevPageToken:
		return &ListConditionsResponse_FieldTerminalPathValue{ListConditionsResponse_FieldTerminalPath: *fp, value: value.(*condition.PagerCursor)}
	case ListConditionsResponse_FieldPathSelectorNextPageToken:
		return &ListConditionsResponse_FieldTerminalPathValue{ListConditionsResponse_FieldTerminalPath: *fp, value: value.(*condition.PagerCursor)}
	case ListConditionsResponse_FieldPathSelectorCurrentOffset:
		return &ListConditionsResponse_FieldTerminalPathValue{ListConditionsResponse_FieldTerminalPath: *fp, value: value.(int32)}
	case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
		return &ListConditionsResponse_FieldTerminalPathValue{ListConditionsResponse_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fp.selector))
	}
}

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

func (fp *ListConditionsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListConditionsResponse_FieldPathArrayOfValues {
	fpaov := &ListConditionsResponse_FieldTerminalPathArrayOfValues{ListConditionsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListConditionsResponse_FieldPathSelectorConditions:
		return &ListConditionsResponse_FieldTerminalPathArrayOfValues{ListConditionsResponse_FieldTerminalPath: *fp, values: values.([][]*condition.Condition)}
	case ListConditionsResponse_FieldPathSelectorPrevPageToken:
		return &ListConditionsResponse_FieldTerminalPathArrayOfValues{ListConditionsResponse_FieldTerminalPath: *fp, values: values.([]*condition.PagerCursor)}
	case ListConditionsResponse_FieldPathSelectorNextPageToken:
		return &ListConditionsResponse_FieldTerminalPathArrayOfValues{ListConditionsResponse_FieldTerminalPath: *fp, values: values.([]*condition.PagerCursor)}
	case ListConditionsResponse_FieldPathSelectorCurrentOffset:
		return &ListConditionsResponse_FieldTerminalPathArrayOfValues{ListConditionsResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
		return &ListConditionsResponse_FieldTerminalPathArrayOfValues{ListConditionsResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *ListConditionsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListConditionsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case ListConditionsResponse_FieldPathSelectorConditions:
		return &ListConditionsResponse_FieldTerminalPathArrayItemValue{ListConditionsResponse_FieldTerminalPath: *fp, value: value.(*condition.Condition)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fp.selector))
	}
}

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

type ListConditionsResponse_FieldSubPath struct {
	selector ListConditionsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListConditionsResponse_FieldPath = (*ListConditionsResponse_FieldSubPath)(nil)

func (fps *ListConditionsResponse_FieldSubPath) Selector() ListConditionsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ListConditionsResponse_FieldSubPath) AsConditionsSubPath() (condition.Condition_FieldPath, bool) {
	res, ok := fps.subPath.(condition.Condition_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source ListConditionsResponse
func (fps *ListConditionsResponse_FieldSubPath) Get(source *ListConditionsResponse) (values []interface{}) {
	switch fps.selector {
	case ListConditionsResponse_FieldPathSelectorConditions:
		for _, item := range source.GetConditions() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fps.selector))
	}
	return
}

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

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

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

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

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

func (fps *ListConditionsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListConditionsResponse))
}

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

func (fps *ListConditionsResponse_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&ListConditionsResponse_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *ListConditionsResponse_FieldSubPath) WithIValue(value interface{}) ListConditionsResponse_FieldPathValue {
	return &ListConditionsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ListConditionsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ListConditionsResponse_FieldPathArrayOfValues {
	return &ListConditionsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ListConditionsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ListConditionsResponse_FieldPathArrayItemValue {
	return &ListConditionsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParseListConditionsResponse_FieldPathValue(pathStr, valueStr string) (ListConditionsResponse_FieldPathValue, error) {
	fp, err := ParseListConditionsResponse_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 ListConditionsResponse field path value from %s: %v", valueStr, err)
	}
	return fpv.(ListConditionsResponse_FieldPathValue), nil
}

func MustParseListConditionsResponse_FieldPathValue(pathStr, valueStr string) ListConditionsResponse_FieldPathValue {
	fpv, err := ParseListConditionsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListConditionsResponse_FieldTerminalPathValue struct {
	ListConditionsResponse_FieldTerminalPath
	value interface{}
}

var _ ListConditionsResponse_FieldPathValue = (*ListConditionsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListConditionsResponse' as interface{}
func (fpv *ListConditionsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListConditionsResponse_FieldTerminalPathValue) AsConditionsValue() ([]*condition.Condition, bool) {
	res, ok := fpv.value.([]*condition.Condition)
	return res, ok
}
func (fpv *ListConditionsResponse_FieldTerminalPathValue) AsPrevPageTokenValue() (*condition.PagerCursor, bool) {
	res, ok := fpv.value.(*condition.PagerCursor)
	return res, ok
}
func (fpv *ListConditionsResponse_FieldTerminalPathValue) AsNextPageTokenValue() (*condition.PagerCursor, bool) {
	res, ok := fpv.value.(*condition.PagerCursor)
	return res, ok
}
func (fpv *ListConditionsResponse_FieldTerminalPathValue) AsCurrentOffsetValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListConditionsResponse_FieldTerminalPathValue) AsTotalResultsCountValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object ListConditionsResponse
func (fpv *ListConditionsResponse_FieldTerminalPathValue) SetTo(target **ListConditionsResponse) {
	if *target == nil {
		*target = new(ListConditionsResponse)
	}
	switch fpv.selector {
	case ListConditionsResponse_FieldPathSelectorConditions:
		(*target).Conditions = fpv.value.([]*condition.Condition)
	case ListConditionsResponse_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*condition.PagerCursor)
	case ListConditionsResponse_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*condition.PagerCursor)
	case ListConditionsResponse_FieldPathSelectorCurrentOffset:
		(*target).CurrentOffset = fpv.value.(int32)
	case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
		(*target).TotalResultsCount = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListConditionsResponse_FieldTerminalPathValue' with the value under path in 'ListConditionsResponse'.
func (fpv *ListConditionsResponse_FieldTerminalPathValue) CompareWith(source *ListConditionsResponse) (int, bool) {
	switch fpv.selector {
	case ListConditionsResponse_FieldPathSelectorConditions:
		return 0, false
	case ListConditionsResponse_FieldPathSelectorPrevPageToken:
		return 0, false
	case ListConditionsResponse_FieldPathSelectorNextPageToken:
		return 0, false
	case ListConditionsResponse_FieldPathSelectorCurrentOffset:
		leftValue := fpv.value.(int32)
		rightValue := source.GetCurrentOffset()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
		leftValue := fpv.value.(int32)
		rightValue := source.GetTotalResultsCount()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConditionsResponse: %d", fpv.selector))
	}
}

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

type ListConditionsResponse_FieldSubPathValue struct {
	ListConditionsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListConditionsResponse_FieldPathValue = (*ListConditionsResponse_FieldSubPathValue)(nil)

func (fpvs *ListConditionsResponse_FieldSubPathValue) AsConditionsPathValue() (condition.Condition_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(condition.Condition_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

// ParseListConditionsResponse_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseListConditionsResponse_FieldPathArrayItemValue(pathStr, valueStr string) (ListConditionsResponse_FieldPathArrayItemValue, error) {
	fp, err := ParseListConditionsResponse_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 ListConditionsResponse field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ListConditionsResponse_FieldPathArrayItemValue), nil
}

func MustParseListConditionsResponse_FieldPathArrayItemValue(pathStr, valueStr string) ListConditionsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseListConditionsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListConditionsResponse_FieldTerminalPathArrayItemValue struct {
	ListConditionsResponse_FieldTerminalPath
	value interface{}
}

var _ ListConditionsResponse_FieldPathArrayItemValue = (*ListConditionsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListConditionsResponse as interface{}
func (fpaiv *ListConditionsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ListConditionsResponse_FieldTerminalPathArrayItemValue) AsConditionsItemValue() (*condition.Condition, bool) {
	res, ok := fpaiv.value.(*condition.Condition)
	return res, ok
}

func (fpaiv *ListConditionsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ListConditionsResponse) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ListConditionsResponse'
func (fpaiv *ListConditionsResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *ListConditionsResponse) bool {
	slice := fpaiv.ListConditionsResponse_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type ListConditionsResponse_FieldSubPathArrayItemValue struct {
	ListConditionsResponse_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ListConditionsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListConditionsResponse_FieldSubPathArrayItemValue) AsConditionsPathItemValue() (condition.Condition_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(condition.Condition_FieldPathArrayItemValue)
	return res, ok
}

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

// ListConditionsResponse_FieldPathArrayOfValues allows storing slice of values for ListConditionsResponse fields according to their type
type ListConditionsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListConditionsResponse_FieldPath
}

func ParseListConditionsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) (ListConditionsResponse_FieldPathArrayOfValues, error) {
	fp, err := ParseListConditionsResponse_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 ListConditionsResponse field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ListConditionsResponse_FieldPathArrayOfValues), nil
}

func MustParseListConditionsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ListConditionsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseListConditionsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListConditionsResponse_FieldTerminalPathArrayOfValues struct {
	ListConditionsResponse_FieldTerminalPath
	values interface{}
}

var _ ListConditionsResponse_FieldPathArrayOfValues = (*ListConditionsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListConditionsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListConditionsResponse_FieldPathSelectorConditions:
		for _, v := range fpaov.values.([][]*condition.Condition) {
			values = append(values, v)
		}
	case ListConditionsResponse_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*condition.PagerCursor) {
			values = append(values, v)
		}
	case ListConditionsResponse_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*condition.PagerCursor) {
			values = append(values, v)
		}
	case ListConditionsResponse_FieldPathSelectorCurrentOffset:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListConditionsResponse_FieldPathSelectorTotalResultsCount:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListConditionsResponse_FieldTerminalPathArrayOfValues) AsConditionsArrayOfValues() ([][]*condition.Condition, bool) {
	res, ok := fpaov.values.([][]*condition.Condition)
	return res, ok
}
func (fpaov *ListConditionsResponse_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*condition.PagerCursor, bool) {
	res, ok := fpaov.values.([]*condition.PagerCursor)
	return res, ok
}
func (fpaov *ListConditionsResponse_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*condition.PagerCursor, bool) {
	res, ok := fpaov.values.([]*condition.PagerCursor)
	return res, ok
}
func (fpaov *ListConditionsResponse_FieldTerminalPathArrayOfValues) AsCurrentOffsetArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListConditionsResponse_FieldTerminalPathArrayOfValues) AsTotalResultsCountArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

type ListConditionsResponse_FieldSubPathArrayOfValues struct {
	ListConditionsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListConditionsResponse_FieldPathArrayOfValues = (*ListConditionsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListConditionsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListConditionsResponse_FieldSubPathArrayOfValues) AsConditionsPathArrayOfValues() (condition.Condition_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(condition.Condition_FieldPathArrayOfValues)
	return res, ok
}

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

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

type WatchConditionRequest_FieldPathSelector int32

const (
	WatchConditionRequest_FieldPathSelectorName      WatchConditionRequest_FieldPathSelector = 0
	WatchConditionRequest_FieldPathSelectorFieldMask WatchConditionRequest_FieldPathSelector = 1
	WatchConditionRequest_FieldPathSelectorView      WatchConditionRequest_FieldPathSelector = 2
)

func (s WatchConditionRequest_FieldPathSelector) String() string {
	switch s {
	case WatchConditionRequest_FieldPathSelectorName:
		return "name"
	case WatchConditionRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchConditionRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionRequest: %d", s))
	}
}

func BuildWatchConditionRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchConditionRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchConditionRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &WatchConditionRequest_FieldTerminalPath{selector: WatchConditionRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchConditionRequest_FieldTerminalPath{selector: WatchConditionRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchConditionRequest_FieldTerminalPath{selector: WatchConditionRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchConditionRequest", fp)
}

func ParseWatchConditionRequest_FieldPath(rawField string) (WatchConditionRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConditionRequest_FieldPath(fp)
}

func MustParseWatchConditionRequest_FieldPath(rawField string) WatchConditionRequest_FieldPath {
	fp, err := ParseWatchConditionRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConditionRequest_FieldTerminalPath struct {
	selector WatchConditionRequest_FieldPathSelector
}

var _ WatchConditionRequest_FieldPath = (*WatchConditionRequest_FieldTerminalPath)(nil)

func (fp *WatchConditionRequest_FieldTerminalPath) Selector() WatchConditionRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchConditionRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConditionRequest_FieldPathSelectorName:
		return (*condition.Reference)(nil)
	case WatchConditionRequest_FieldPathSelectorFieldMask:
		return (*condition.Condition_FieldMask)(nil)
	case WatchConditionRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionRequest: %d", fp.selector))
	}
}

func (fp *WatchConditionRequest_FieldTerminalPath) ClearValue(item *WatchConditionRequest) {
	if item != nil {
		switch fp.selector {
		case WatchConditionRequest_FieldPathSelectorName:
			item.Name = nil
		case WatchConditionRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchConditionRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConditionRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchConditionRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConditionRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchConditionRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchConditionRequest_FieldPathSelectorName ||
		fp.selector == WatchConditionRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchConditionRequest_FieldPathSelectorView
}

func (fp *WatchConditionRequest_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *WatchConditionRequest_FieldTerminalPath) WithIValue(value interface{}) WatchConditionRequest_FieldPathValue {
	switch fp.selector {
	case WatchConditionRequest_FieldPathSelectorName:
		return &WatchConditionRequest_FieldTerminalPathValue{WatchConditionRequest_FieldTerminalPath: *fp, value: value.(*condition.Reference)}
	case WatchConditionRequest_FieldPathSelectorFieldMask:
		return &WatchConditionRequest_FieldTerminalPathValue{WatchConditionRequest_FieldTerminalPath: *fp, value: value.(*condition.Condition_FieldMask)}
	case WatchConditionRequest_FieldPathSelectorView:
		return &WatchConditionRequest_FieldTerminalPathValue{WatchConditionRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionRequest: %d", fp.selector))
	}
}

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

func (fp *WatchConditionRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConditionRequest_FieldPathArrayOfValues {
	fpaov := &WatchConditionRequest_FieldTerminalPathArrayOfValues{WatchConditionRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConditionRequest_FieldPathSelectorName:
		return &WatchConditionRequest_FieldTerminalPathArrayOfValues{WatchConditionRequest_FieldTerminalPath: *fp, values: values.([]*condition.Reference)}
	case WatchConditionRequest_FieldPathSelectorFieldMask:
		return &WatchConditionRequest_FieldTerminalPathArrayOfValues{WatchConditionRequest_FieldTerminalPath: *fp, values: values.([]*condition.Condition_FieldMask)}
	case WatchConditionRequest_FieldPathSelectorView:
		return &WatchConditionRequest_FieldTerminalPathArrayOfValues{WatchConditionRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParseWatchConditionRequest_FieldPathValue(pathStr, valueStr string) (WatchConditionRequest_FieldPathValue, error) {
	fp, err := ParseWatchConditionRequest_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 WatchConditionRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(WatchConditionRequest_FieldPathValue), nil
}

func MustParseWatchConditionRequest_FieldPathValue(pathStr, valueStr string) WatchConditionRequest_FieldPathValue {
	fpv, err := ParseWatchConditionRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConditionRequest_FieldTerminalPathValue struct {
	WatchConditionRequest_FieldTerminalPath
	value interface{}
}

var _ WatchConditionRequest_FieldPathValue = (*WatchConditionRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object WatchConditionRequest
func (fpv *WatchConditionRequest_FieldTerminalPathValue) SetTo(target **WatchConditionRequest) {
	if *target == nil {
		*target = new(WatchConditionRequest)
	}
	switch fpv.selector {
	case WatchConditionRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*condition.Reference)
	case WatchConditionRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*condition.Condition_FieldMask)
	case WatchConditionRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchConditionRequest_FieldTerminalPathValue' with the value under path in 'WatchConditionRequest'.
func (fpv *WatchConditionRequest_FieldTerminalPathValue) CompareWith(source *WatchConditionRequest) (int, bool) {
	switch fpv.selector {
	case WatchConditionRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*condition.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 WatchConditionRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchConditionRequest_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 WatchConditionRequest: %d", fpv.selector))
	}
}

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

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

// ParseWatchConditionRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) (WatchConditionRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchConditionRequest_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 WatchConditionRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(WatchConditionRequest_FieldPathArrayItemValue), nil
}

func MustParseWatchConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchConditionRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConditionRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConditionRequest_FieldTerminalPathArrayItemValue struct {
	WatchConditionRequest_FieldTerminalPath
	value interface{}
}

var _ WatchConditionRequest_FieldPathArrayItemValue = (*WatchConditionRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchConditionRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConditionRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'WatchConditionRequest'
func (fpaiv *WatchConditionRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConditionRequest) bool {
	slice := fpaiv.WatchConditionRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// WatchConditionRequest_FieldPathArrayOfValues allows storing slice of values for WatchConditionRequest fields according to their type
type WatchConditionRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchConditionRequest_FieldPath
}

func ParseWatchConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchConditionRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchConditionRequest_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 WatchConditionRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(WatchConditionRequest_FieldPathArrayOfValues), nil
}

func MustParseWatchConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConditionRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConditionRequest_FieldTerminalPathArrayOfValues struct {
	WatchConditionRequest_FieldTerminalPath
	values interface{}
}

var _ WatchConditionRequest_FieldPathArrayOfValues = (*WatchConditionRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConditionRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConditionRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*condition.Reference) {
			values = append(values, v)
		}
	case WatchConditionRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*condition.Condition_FieldMask) {
			values = append(values, v)
		}
	case WatchConditionRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConditionRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*condition.Reference, bool) {
	res, ok := fpaov.values.([]*condition.Reference)
	return res, ok
}
func (fpaov *WatchConditionRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*condition.Condition_FieldMask, bool) {
	res, ok := fpaov.values.([]*condition.Condition_FieldMask)
	return res, ok
}
func (fpaov *WatchConditionRequest_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 WatchConditionResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchConditionResponse_FieldPathSelector
	Get(source *WatchConditionResponse) []interface{}
	GetSingle(source *WatchConditionResponse) (interface{}, bool)
	ClearValue(item *WatchConditionResponse)

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

type WatchConditionResponse_FieldPathSelector int32

const (
	WatchConditionResponse_FieldPathSelectorChange WatchConditionResponse_FieldPathSelector = 0
)

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

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

func ParseWatchConditionResponse_FieldPath(rawField string) (WatchConditionResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConditionResponse_FieldPath(fp)
}

func MustParseWatchConditionResponse_FieldPath(rawField string) WatchConditionResponse_FieldPath {
	fp, err := ParseWatchConditionResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConditionResponse_FieldTerminalPath struct {
	selector WatchConditionResponse_FieldPathSelector
}

var _ WatchConditionResponse_FieldPath = (*WatchConditionResponse_FieldTerminalPath)(nil)

func (fp *WatchConditionResponse_FieldTerminalPath) Selector() WatchConditionResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchConditionResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConditionResponse_FieldPathSelectorChange:
		return (*condition.ConditionChange)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionResponse: %d", fp.selector))
	}
}

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

func (fp *WatchConditionResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConditionResponse))
}

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

func (fp *WatchConditionResponse_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *WatchConditionResponse_FieldTerminalPath) WithIValue(value interface{}) WatchConditionResponse_FieldPathValue {
	switch fp.selector {
	case WatchConditionResponse_FieldPathSelectorChange:
		return &WatchConditionResponse_FieldTerminalPathValue{WatchConditionResponse_FieldTerminalPath: *fp, value: value.(*condition.ConditionChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionResponse: %d", fp.selector))
	}
}

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

func (fp *WatchConditionResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConditionResponse_FieldPathArrayOfValues {
	fpaov := &WatchConditionResponse_FieldTerminalPathArrayOfValues{WatchConditionResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConditionResponse_FieldPathSelectorChange:
		return &WatchConditionResponse_FieldTerminalPathArrayOfValues{WatchConditionResponse_FieldTerminalPath: *fp, values: values.([]*condition.ConditionChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParseWatchConditionResponse_FieldPathValue(pathStr, valueStr string) (WatchConditionResponse_FieldPathValue, error) {
	fp, err := ParseWatchConditionResponse_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 WatchConditionResponse field path value from %s: %v", valueStr, err)
	}
	return fpv.(WatchConditionResponse_FieldPathValue), nil
}

func MustParseWatchConditionResponse_FieldPathValue(pathStr, valueStr string) WatchConditionResponse_FieldPathValue {
	fpv, err := ParseWatchConditionResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConditionResponse_FieldTerminalPathValue struct {
	WatchConditionResponse_FieldTerminalPath
	value interface{}
}

var _ WatchConditionResponse_FieldPathValue = (*WatchConditionResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchConditionResponse' as interface{}
func (fpv *WatchConditionResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchConditionResponse_FieldTerminalPathValue) AsChangeValue() (*condition.ConditionChange, bool) {
	res, ok := fpv.value.(*condition.ConditionChange)
	return res, ok
}

// SetTo stores value for selected field for object WatchConditionResponse
func (fpv *WatchConditionResponse_FieldTerminalPathValue) SetTo(target **WatchConditionResponse) {
	if *target == nil {
		*target = new(WatchConditionResponse)
	}
	switch fpv.selector {
	case WatchConditionResponse_FieldPathSelectorChange:
		(*target).Change = fpv.value.(*condition.ConditionChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionResponse: %d", fpv.selector))
	}
}

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

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

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

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

// ParseWatchConditionResponse_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchConditionResponse_FieldPathArrayItemValue(pathStr, valueStr string) (WatchConditionResponse_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchConditionResponse_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 WatchConditionResponse field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(WatchConditionResponse_FieldPathArrayItemValue), nil
}

func MustParseWatchConditionResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchConditionResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConditionResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConditionResponse_FieldTerminalPathArrayItemValue struct {
	WatchConditionResponse_FieldTerminalPath
	value interface{}
}

var _ WatchConditionResponse_FieldPathArrayItemValue = (*WatchConditionResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchConditionResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConditionResponse) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'WatchConditionResponse'
func (fpaiv *WatchConditionResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConditionResponse) bool {
	slice := fpaiv.WatchConditionResponse_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// WatchConditionResponse_FieldPathArrayOfValues allows storing slice of values for WatchConditionResponse fields according to their type
type WatchConditionResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchConditionResponse_FieldPath
}

func ParseWatchConditionResponse_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchConditionResponse_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchConditionResponse_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 WatchConditionResponse field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(WatchConditionResponse_FieldPathArrayOfValues), nil
}

func MustParseWatchConditionResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConditionResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConditionResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConditionResponse_FieldTerminalPathArrayOfValues struct {
	WatchConditionResponse_FieldTerminalPath
	values interface{}
}

var _ WatchConditionResponse_FieldPathArrayOfValues = (*WatchConditionResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConditionResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConditionResponse_FieldPathSelectorChange:
		for _, v := range fpaov.values.([]*condition.ConditionChange) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConditionResponse_FieldTerminalPathArrayOfValues) AsChangeArrayOfValues() ([]*condition.ConditionChange, bool) {
	res, ok := fpaov.values.([]*condition.ConditionChange)
	return res, ok
}

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

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

type WatchConditionsRequest_FieldPathSelector int32

const (
	WatchConditionsRequest_FieldPathSelectorType         WatchConditionsRequest_FieldPathSelector = 0
	WatchConditionsRequest_FieldPathSelectorParent       WatchConditionsRequest_FieldPathSelector = 1
	WatchConditionsRequest_FieldPathSelectorPageSize     WatchConditionsRequest_FieldPathSelector = 2
	WatchConditionsRequest_FieldPathSelectorPageToken    WatchConditionsRequest_FieldPathSelector = 3
	WatchConditionsRequest_FieldPathSelectorOrderBy      WatchConditionsRequest_FieldPathSelector = 4
	WatchConditionsRequest_FieldPathSelectorResumeToken  WatchConditionsRequest_FieldPathSelector = 5
	WatchConditionsRequest_FieldPathSelectorStartingTime WatchConditionsRequest_FieldPathSelector = 6
	WatchConditionsRequest_FieldPathSelectorFilter       WatchConditionsRequest_FieldPathSelector = 7
	WatchConditionsRequest_FieldPathSelectorFieldMask    WatchConditionsRequest_FieldPathSelector = 8
	WatchConditionsRequest_FieldPathSelectorView         WatchConditionsRequest_FieldPathSelector = 9
	WatchConditionsRequest_FieldPathSelectorMaxChunkSize WatchConditionsRequest_FieldPathSelector = 10
)

func (s WatchConditionsRequest_FieldPathSelector) String() string {
	switch s {
	case WatchConditionsRequest_FieldPathSelectorType:
		return "type"
	case WatchConditionsRequest_FieldPathSelectorParent:
		return "parent"
	case WatchConditionsRequest_FieldPathSelectorPageSize:
		return "page_size"
	case WatchConditionsRequest_FieldPathSelectorPageToken:
		return "page_token"
	case WatchConditionsRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case WatchConditionsRequest_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchConditionsRequest_FieldPathSelectorStartingTime:
		return "starting_time"
	case WatchConditionsRequest_FieldPathSelectorFilter:
		return "filter"
	case WatchConditionsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchConditionsRequest_FieldPathSelectorView:
		return "view"
	case WatchConditionsRequest_FieldPathSelectorMaxChunkSize:
		return "max_chunk_size"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsRequest: %d", s))
	}
}

func BuildWatchConditionsRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchConditionsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchConditionsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorType}, nil
		case "parent":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorOrderBy}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorResumeToken}, nil
		case "starting_time", "startingTime", "starting-time":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorStartingTime}, nil
		case "filter":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorView}, nil
		case "max_chunk_size", "maxChunkSize", "max-chunk-size":
			return &WatchConditionsRequest_FieldTerminalPath{selector: WatchConditionsRequest_FieldPathSelectorMaxChunkSize}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchConditionsRequest", fp)
}

func ParseWatchConditionsRequest_FieldPath(rawField string) (WatchConditionsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConditionsRequest_FieldPath(fp)
}

func MustParseWatchConditionsRequest_FieldPath(rawField string) WatchConditionsRequest_FieldPath {
	fp, err := ParseWatchConditionsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConditionsRequest_FieldTerminalPath struct {
	selector WatchConditionsRequest_FieldPathSelector
}

var _ WatchConditionsRequest_FieldPath = (*WatchConditionsRequest_FieldTerminalPath)(nil)

func (fp *WatchConditionsRequest_FieldTerminalPath) Selector() WatchConditionsRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchConditionsRequest
func (fp *WatchConditionsRequest_FieldTerminalPath) Get(source *WatchConditionsRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchConditionsRequest_FieldPathSelectorType:
			values = append(values, source.Type)
		case WatchConditionsRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case WatchConditionsRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case WatchConditionsRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case WatchConditionsRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case WatchConditionsRequest_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchConditionsRequest_FieldPathSelectorStartingTime:
			if source.StartingTime != nil {
				values = append(values, source.StartingTime)
			}
		case WatchConditionsRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case WatchConditionsRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchConditionsRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case WatchConditionsRequest_FieldPathSelectorMaxChunkSize:
			values = append(values, source.MaxChunkSize)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConditionsRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchConditionsRequest
func (fp *WatchConditionsRequest_FieldTerminalPath) GetSingle(source *WatchConditionsRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchConditionsRequest_FieldPathSelectorType:
		return source.GetType(), source != nil
	case WatchConditionsRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case WatchConditionsRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case WatchConditionsRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case WatchConditionsRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case WatchConditionsRequest_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchConditionsRequest_FieldPathSelectorStartingTime:
		res := source.GetStartingTime()
		return res, res != nil
	case WatchConditionsRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case WatchConditionsRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchConditionsRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case WatchConditionsRequest_FieldPathSelectorMaxChunkSize:
		return source.GetMaxChunkSize(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchConditionsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConditionsRequest_FieldPathSelectorType:
		return watch_type.WatchType_STATEFUL
	case WatchConditionsRequest_FieldPathSelectorParent:
		return (*condition.ParentReference)(nil)
	case WatchConditionsRequest_FieldPathSelectorPageSize:
		return int32(0)
	case WatchConditionsRequest_FieldPathSelectorPageToken:
		return (*condition.PagerCursor)(nil)
	case WatchConditionsRequest_FieldPathSelectorOrderBy:
		return (*condition.OrderBy)(nil)
	case WatchConditionsRequest_FieldPathSelectorResumeToken:
		return ""
	case WatchConditionsRequest_FieldPathSelectorStartingTime:
		return (*timestamp.Timestamp)(nil)
	case WatchConditionsRequest_FieldPathSelectorFilter:
		return (*condition.Filter)(nil)
	case WatchConditionsRequest_FieldPathSelectorFieldMask:
		return (*condition.Condition_FieldMask)(nil)
	case WatchConditionsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case WatchConditionsRequest_FieldPathSelectorMaxChunkSize:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsRequest: %d", fp.selector))
	}
}

func (fp *WatchConditionsRequest_FieldTerminalPath) ClearValue(item *WatchConditionsRequest) {
	if item != nil {
		switch fp.selector {
		case WatchConditionsRequest_FieldPathSelectorType:
			item.Type = watch_type.WatchType_STATEFUL
		case WatchConditionsRequest_FieldPathSelectorParent:
			item.Parent = nil
		case WatchConditionsRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case WatchConditionsRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case WatchConditionsRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case WatchConditionsRequest_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchConditionsRequest_FieldPathSelectorStartingTime:
			item.StartingTime = nil
		case WatchConditionsRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case WatchConditionsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchConditionsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case WatchConditionsRequest_FieldPathSelectorMaxChunkSize:
			item.MaxChunkSize = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConditionsRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchConditionsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConditionsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchConditionsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchConditionsRequest_FieldPathSelectorType ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorParent ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorPageSize ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorPageToken ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorOrderBy ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorResumeToken ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorStartingTime ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorFilter ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorView ||
		fp.selector == WatchConditionsRequest_FieldPathSelectorMaxChunkSize
}

func (fp *WatchConditionsRequest_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *WatchConditionsRequest_FieldTerminalPath) WithIValue(value interface{}) WatchConditionsRequest_FieldPathValue {
	switch fp.selector {
	case WatchConditionsRequest_FieldPathSelectorType:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(watch_type.WatchType)}
	case WatchConditionsRequest_FieldPathSelectorParent:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.ParentReference)}
	case WatchConditionsRequest_FieldPathSelectorPageSize:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case WatchConditionsRequest_FieldPathSelectorPageToken:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.PagerCursor)}
	case WatchConditionsRequest_FieldPathSelectorOrderBy:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.OrderBy)}
	case WatchConditionsRequest_FieldPathSelectorResumeToken:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(string)}
	case WatchConditionsRequest_FieldPathSelectorStartingTime:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(*timestamp.Timestamp)}
	case WatchConditionsRequest_FieldPathSelectorFilter:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.Filter)}
	case WatchConditionsRequest_FieldPathSelectorFieldMask:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(*condition.Condition_FieldMask)}
	case WatchConditionsRequest_FieldPathSelectorView:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case WatchConditionsRequest_FieldPathSelectorMaxChunkSize:
		return &WatchConditionsRequest_FieldTerminalPathValue{WatchConditionsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsRequest: %d", fp.selector))
	}
}

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

func (fp *WatchConditionsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConditionsRequest_FieldPathArrayOfValues {
	fpaov := &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConditionsRequest_FieldPathSelectorType:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]watch_type.WatchType)}
	case WatchConditionsRequest_FieldPathSelectorParent:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.ParentReference)}
	case WatchConditionsRequest_FieldPathSelectorPageSize:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case WatchConditionsRequest_FieldPathSelectorPageToken:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.PagerCursor)}
	case WatchConditionsRequest_FieldPathSelectorOrderBy:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.OrderBy)}
	case WatchConditionsRequest_FieldPathSelectorResumeToken:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchConditionsRequest_FieldPathSelectorStartingTime:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]*timestamp.Timestamp)}
	case WatchConditionsRequest_FieldPathSelectorFilter:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.Filter)}
	case WatchConditionsRequest_FieldPathSelectorFieldMask:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]*condition.Condition_FieldMask)}
	case WatchConditionsRequest_FieldPathSelectorView:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case WatchConditionsRequest_FieldPathSelectorMaxChunkSize:
		return &WatchConditionsRequest_FieldTerminalPathArrayOfValues{WatchConditionsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParseWatchConditionsRequest_FieldPathValue(pathStr, valueStr string) (WatchConditionsRequest_FieldPathValue, error) {
	fp, err := ParseWatchConditionsRequest_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 WatchConditionsRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(WatchConditionsRequest_FieldPathValue), nil
}

func MustParseWatchConditionsRequest_FieldPathValue(pathStr, valueStr string) WatchConditionsRequest_FieldPathValue {
	fpv, err := ParseWatchConditionsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConditionsRequest_FieldTerminalPathValue struct {
	WatchConditionsRequest_FieldTerminalPath
	value interface{}
}

var _ WatchConditionsRequest_FieldPathValue = (*WatchConditionsRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchConditionsRequest' as interface{}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsTypeValue() (watch_type.WatchType, bool) {
	res, ok := fpv.value.(watch_type.WatchType)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsParentValue() (*condition.ParentReference, bool) {
	res, ok := fpv.value.(*condition.ParentReference)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsPageSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsPageTokenValue() (*condition.PagerCursor, bool) {
	res, ok := fpv.value.(*condition.PagerCursor)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsOrderByValue() (*condition.OrderBy, bool) {
	res, ok := fpv.value.(*condition.OrderBy)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsStartingTimeValue() (*timestamp.Timestamp, bool) {
	res, ok := fpv.value.(*timestamp.Timestamp)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsFilterValue() (*condition.Filter, bool) {
	res, ok := fpv.value.(*condition.Filter)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsFieldMaskValue() (*condition.Condition_FieldMask, bool) {
	res, ok := fpv.value.(*condition.Condition_FieldMask)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) AsMaxChunkSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object WatchConditionsRequest
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) SetTo(target **WatchConditionsRequest) {
	if *target == nil {
		*target = new(WatchConditionsRequest)
	}
	switch fpv.selector {
	case WatchConditionsRequest_FieldPathSelectorType:
		(*target).Type = fpv.value.(watch_type.WatchType)
	case WatchConditionsRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*condition.ParentReference)
	case WatchConditionsRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case WatchConditionsRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*condition.PagerCursor)
	case WatchConditionsRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*condition.OrderBy)
	case WatchConditionsRequest_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchConditionsRequest_FieldPathSelectorStartingTime:
		(*target).StartingTime = fpv.value.(*timestamp.Timestamp)
	case WatchConditionsRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*condition.Filter)
	case WatchConditionsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*condition.Condition_FieldMask)
	case WatchConditionsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case WatchConditionsRequest_FieldPathSelectorMaxChunkSize:
		(*target).MaxChunkSize = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchConditionsRequest_FieldTerminalPathValue' with the value under path in 'WatchConditionsRequest'.
func (fpv *WatchConditionsRequest_FieldTerminalPathValue) CompareWith(source *WatchConditionsRequest) (int, bool) {
	switch fpv.selector {
	case WatchConditionsRequest_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 WatchConditionsRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*condition.ParentReference)
		rightValue := source.GetParent()
		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 WatchConditionsRequest_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 WatchConditionsRequest_FieldPathSelectorPageToken:
		return 0, false
	case WatchConditionsRequest_FieldPathSelectorOrderBy:
		return 0, false
	case WatchConditionsRequest_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 WatchConditionsRequest_FieldPathSelectorStartingTime:
		leftValue := fpv.value.(*timestamp.Timestamp)
		rightValue := source.GetStartingTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchConditionsRequest_FieldPathSelectorFilter:
		return 0, false
	case WatchConditionsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchConditionsRequest_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 WatchConditionsRequest_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 WatchConditionsRequest: %d", fpv.selector))
	}
}

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

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

// ParseWatchConditionsRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchConditionsRequest_FieldPathArrayItemValue(pathStr, valueStr string) (WatchConditionsRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchConditionsRequest_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 WatchConditionsRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(WatchConditionsRequest_FieldPathArrayItemValue), nil
}

func MustParseWatchConditionsRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchConditionsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConditionsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConditionsRequest_FieldTerminalPathArrayItemValue struct {
	WatchConditionsRequest_FieldTerminalPath
	value interface{}
}

var _ WatchConditionsRequest_FieldPathArrayItemValue = (*WatchConditionsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchConditionsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConditionsRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'WatchConditionsRequest'
func (fpaiv *WatchConditionsRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConditionsRequest) bool {
	slice := fpaiv.WatchConditionsRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// WatchConditionsRequest_FieldPathArrayOfValues allows storing slice of values for WatchConditionsRequest fields according to their type
type WatchConditionsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchConditionsRequest_FieldPath
}

func ParseWatchConditionsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchConditionsRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchConditionsRequest_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 WatchConditionsRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(WatchConditionsRequest_FieldPathArrayOfValues), nil
}

func MustParseWatchConditionsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConditionsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConditionsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConditionsRequest_FieldTerminalPathArrayOfValues struct {
	WatchConditionsRequest_FieldTerminalPath
	values interface{}
}

var _ WatchConditionsRequest_FieldPathArrayOfValues = (*WatchConditionsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConditionsRequest_FieldPathSelectorType:
		for _, v := range fpaov.values.([]watch_type.WatchType) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*condition.ParentReference) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*condition.PagerCursor) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*condition.OrderBy) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorStartingTime:
		for _, v := range fpaov.values.([]*timestamp.Timestamp) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*condition.Filter) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*condition.Condition_FieldMask) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case WatchConditionsRequest_FieldPathSelectorMaxChunkSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]watch_type.WatchType, bool) {
	res, ok := fpaov.values.([]watch_type.WatchType)
	return res, ok
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*condition.ParentReference, bool) {
	res, ok := fpaov.values.([]*condition.ParentReference)
	return res, ok
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*condition.PagerCursor, bool) {
	res, ok := fpaov.values.([]*condition.PagerCursor)
	return res, ok
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*condition.OrderBy, bool) {
	res, ok := fpaov.values.([]*condition.OrderBy)
	return res, ok
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsStartingTimeArrayOfValues() ([]*timestamp.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamp.Timestamp)
	return res, ok
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*condition.Filter, bool) {
	res, ok := fpaov.values.([]*condition.Filter)
	return res, ok
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*condition.Condition_FieldMask, bool) {
	res, ok := fpaov.values.([]*condition.Condition_FieldMask)
	return res, ok
}
func (fpaov *WatchConditionsRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *WatchConditionsRequest_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 WatchConditionsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchConditionsResponse_FieldPathSelector
	Get(source *WatchConditionsResponse) []interface{}
	GetSingle(source *WatchConditionsResponse) (interface{}, bool)
	ClearValue(item *WatchConditionsResponse)

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

type WatchConditionsResponse_FieldPathSelector int32

const (
	WatchConditionsResponse_FieldPathSelectorConditionChanges WatchConditionsResponse_FieldPathSelector = 0
	WatchConditionsResponse_FieldPathSelectorIsCurrent        WatchConditionsResponse_FieldPathSelector = 1
	WatchConditionsResponse_FieldPathSelectorPageTokenChange  WatchConditionsResponse_FieldPathSelector = 2
	WatchConditionsResponse_FieldPathSelectorResumeToken      WatchConditionsResponse_FieldPathSelector = 3
	WatchConditionsResponse_FieldPathSelectorSnapshotSize     WatchConditionsResponse_FieldPathSelector = 4
	WatchConditionsResponse_FieldPathSelectorIsSoftReset      WatchConditionsResponse_FieldPathSelector = 5
	WatchConditionsResponse_FieldPathSelectorIsHardReset      WatchConditionsResponse_FieldPathSelector = 6
)

func (s WatchConditionsResponse_FieldPathSelector) String() string {
	switch s {
	case WatchConditionsResponse_FieldPathSelectorConditionChanges:
		return "condition_changes"
	case WatchConditionsResponse_FieldPathSelectorIsCurrent:
		return "is_current"
	case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		return "page_token_change"
	case WatchConditionsResponse_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchConditionsResponse_FieldPathSelectorSnapshotSize:
		return "snapshot_size"
	case WatchConditionsResponse_FieldPathSelectorIsSoftReset:
		return "is_soft_reset"
	case WatchConditionsResponse_FieldPathSelectorIsHardReset:
		return "is_hard_reset"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", s))
	}
}

func BuildWatchConditionsResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchConditionsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchConditionsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "condition_changes", "conditionChanges", "condition-changes":
			return &WatchConditionsResponse_FieldTerminalPath{selector: WatchConditionsResponse_FieldPathSelectorConditionChanges}, nil
		case "is_current", "isCurrent", "is-current":
			return &WatchConditionsResponse_FieldTerminalPath{selector: WatchConditionsResponse_FieldPathSelectorIsCurrent}, nil
		case "page_token_change", "pageTokenChange", "page-token-change":
			return &WatchConditionsResponse_FieldTerminalPath{selector: WatchConditionsResponse_FieldPathSelectorPageTokenChange}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchConditionsResponse_FieldTerminalPath{selector: WatchConditionsResponse_FieldPathSelectorResumeToken}, nil
		case "snapshot_size", "snapshotSize", "snapshot-size":
			return &WatchConditionsResponse_FieldTerminalPath{selector: WatchConditionsResponse_FieldPathSelectorSnapshotSize}, nil
		case "is_soft_reset", "isSoftReset", "is-soft-reset":
			return &WatchConditionsResponse_FieldTerminalPath{selector: WatchConditionsResponse_FieldPathSelectorIsSoftReset}, nil
		case "is_hard_reset", "isHardReset", "is-hard-reset":
			return &WatchConditionsResponse_FieldTerminalPath{selector: WatchConditionsResponse_FieldPathSelectorIsHardReset}, nil
		}
	} else {
		switch fp[0] {
		case "page_token_change", "pageTokenChange", "page-token-change":
			if subpath, err := BuildWatchConditionsResponsePageTokenChange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &WatchConditionsResponse_FieldSubPath{selector: WatchConditionsResponse_FieldPathSelectorPageTokenChange, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchConditionsResponse", fp)
}

func ParseWatchConditionsResponse_FieldPath(rawField string) (WatchConditionsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConditionsResponse_FieldPath(fp)
}

func MustParseWatchConditionsResponse_FieldPath(rawField string) WatchConditionsResponse_FieldPath {
	fp, err := ParseWatchConditionsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConditionsResponse_FieldTerminalPath struct {
	selector WatchConditionsResponse_FieldPathSelector
}

var _ WatchConditionsResponse_FieldPath = (*WatchConditionsResponse_FieldTerminalPath)(nil)

func (fp *WatchConditionsResponse_FieldTerminalPath) Selector() WatchConditionsResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchConditionsResponse
func (fp *WatchConditionsResponse_FieldTerminalPath) Get(source *WatchConditionsResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchConditionsResponse_FieldPathSelectorConditionChanges:
			for _, value := range source.GetConditionChanges() {
				values = append(values, value)
			}
		case WatchConditionsResponse_FieldPathSelectorIsCurrent:
			values = append(values, source.IsCurrent)
		case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
			if source.PageTokenChange != nil {
				values = append(values, source.PageTokenChange)
			}
		case WatchConditionsResponse_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchConditionsResponse_FieldPathSelectorSnapshotSize:
			values = append(values, source.SnapshotSize)
		case WatchConditionsResponse_FieldPathSelectorIsSoftReset:
			values = append(values, source.IsSoftReset)
		case WatchConditionsResponse_FieldPathSelectorIsHardReset:
			values = append(values, source.IsHardReset)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchConditionsResponse
func (fp *WatchConditionsResponse_FieldTerminalPath) GetSingle(source *WatchConditionsResponse) (interface{}, bool) {
	switch fp.selector {
	case WatchConditionsResponse_FieldPathSelectorConditionChanges:
		res := source.GetConditionChanges()
		return res, res != nil
	case WatchConditionsResponse_FieldPathSelectorIsCurrent:
		return source.GetIsCurrent(), source != nil
	case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		res := source.GetPageTokenChange()
		return res, res != nil
	case WatchConditionsResponse_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchConditionsResponse_FieldPathSelectorSnapshotSize:
		return source.GetSnapshotSize(), source != nil
	case WatchConditionsResponse_FieldPathSelectorIsSoftReset:
		return source.GetIsSoftReset(), source != nil
	case WatchConditionsResponse_FieldPathSelectorIsHardReset:
		return source.GetIsHardReset(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchConditionsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConditionsResponse_FieldPathSelectorConditionChanges:
		return ([]*condition.ConditionChange)(nil)
	case WatchConditionsResponse_FieldPathSelectorIsCurrent:
		return false
	case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		return (*WatchConditionsResponse_PageTokenChange)(nil)
	case WatchConditionsResponse_FieldPathSelectorResumeToken:
		return ""
	case WatchConditionsResponse_FieldPathSelectorSnapshotSize:
		return int64(0)
	case WatchConditionsResponse_FieldPathSelectorIsSoftReset:
		return false
	case WatchConditionsResponse_FieldPathSelectorIsHardReset:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fp.selector))
	}
}

func (fp *WatchConditionsResponse_FieldTerminalPath) ClearValue(item *WatchConditionsResponse) {
	if item != nil {
		switch fp.selector {
		case WatchConditionsResponse_FieldPathSelectorConditionChanges:
			item.ConditionChanges = nil
		case WatchConditionsResponse_FieldPathSelectorIsCurrent:
			item.IsCurrent = false
		case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
			item.PageTokenChange = nil
		case WatchConditionsResponse_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchConditionsResponse_FieldPathSelectorSnapshotSize:
			item.SnapshotSize = int64(0)
		case WatchConditionsResponse_FieldPathSelectorIsSoftReset:
			item.IsSoftReset = false
		case WatchConditionsResponse_FieldPathSelectorIsHardReset:
			item.IsHardReset = false
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchConditionsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConditionsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchConditionsResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchConditionsResponse_FieldPathSelectorConditionChanges ||
		fp.selector == WatchConditionsResponse_FieldPathSelectorIsCurrent ||
		fp.selector == WatchConditionsResponse_FieldPathSelectorResumeToken ||
		fp.selector == WatchConditionsResponse_FieldPathSelectorSnapshotSize ||
		fp.selector == WatchConditionsResponse_FieldPathSelectorIsSoftReset ||
		fp.selector == WatchConditionsResponse_FieldPathSelectorIsHardReset
}

func (fp *WatchConditionsResponse_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *WatchConditionsResponse_FieldTerminalPath) WithIValue(value interface{}) WatchConditionsResponse_FieldPathValue {
	switch fp.selector {
	case WatchConditionsResponse_FieldPathSelectorConditionChanges:
		return &WatchConditionsResponse_FieldTerminalPathValue{WatchConditionsResponse_FieldTerminalPath: *fp, value: value.([]*condition.ConditionChange)}
	case WatchConditionsResponse_FieldPathSelectorIsCurrent:
		return &WatchConditionsResponse_FieldTerminalPathValue{WatchConditionsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		return &WatchConditionsResponse_FieldTerminalPathValue{WatchConditionsResponse_FieldTerminalPath: *fp, value: value.(*WatchConditionsResponse_PageTokenChange)}
	case WatchConditionsResponse_FieldPathSelectorResumeToken:
		return &WatchConditionsResponse_FieldTerminalPathValue{WatchConditionsResponse_FieldTerminalPath: *fp, value: value.(string)}
	case WatchConditionsResponse_FieldPathSelectorSnapshotSize:
		return &WatchConditionsResponse_FieldTerminalPathValue{WatchConditionsResponse_FieldTerminalPath: *fp, value: value.(int64)}
	case WatchConditionsResponse_FieldPathSelectorIsSoftReset:
		return &WatchConditionsResponse_FieldTerminalPathValue{WatchConditionsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchConditionsResponse_FieldPathSelectorIsHardReset:
		return &WatchConditionsResponse_FieldTerminalPathValue{WatchConditionsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fp.selector))
	}
}

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

func (fp *WatchConditionsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConditionsResponse_FieldPathArrayOfValues {
	fpaov := &WatchConditionsResponse_FieldTerminalPathArrayOfValues{WatchConditionsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConditionsResponse_FieldPathSelectorConditionChanges:
		return &WatchConditionsResponse_FieldTerminalPathArrayOfValues{WatchConditionsResponse_FieldTerminalPath: *fp, values: values.([][]*condition.ConditionChange)}
	case WatchConditionsResponse_FieldPathSelectorIsCurrent:
		return &WatchConditionsResponse_FieldTerminalPathArrayOfValues{WatchConditionsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		return &WatchConditionsResponse_FieldTerminalPathArrayOfValues{WatchConditionsResponse_FieldTerminalPath: *fp, values: values.([]*WatchConditionsResponse_PageTokenChange)}
	case WatchConditionsResponse_FieldPathSelectorResumeToken:
		return &WatchConditionsResponse_FieldTerminalPathArrayOfValues{WatchConditionsResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchConditionsResponse_FieldPathSelectorSnapshotSize:
		return &WatchConditionsResponse_FieldTerminalPathArrayOfValues{WatchConditionsResponse_FieldTerminalPath: *fp, values: values.([]int64)}
	case WatchConditionsResponse_FieldPathSelectorIsSoftReset:
		return &WatchConditionsResponse_FieldTerminalPathArrayOfValues{WatchConditionsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchConditionsResponse_FieldPathSelectorIsHardReset:
		return &WatchConditionsResponse_FieldTerminalPathArrayOfValues{WatchConditionsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *WatchConditionsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchConditionsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case WatchConditionsResponse_FieldPathSelectorConditionChanges:
		return &WatchConditionsResponse_FieldTerminalPathArrayItemValue{WatchConditionsResponse_FieldTerminalPath: *fp, value: value.(*condition.ConditionChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fp.selector))
	}
}

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

type WatchConditionsResponse_FieldSubPath struct {
	selector WatchConditionsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ WatchConditionsResponse_FieldPath = (*WatchConditionsResponse_FieldSubPath)(nil)

func (fps *WatchConditionsResponse_FieldSubPath) Selector() WatchConditionsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *WatchConditionsResponse_FieldSubPath) AsPageTokenChangeSubPath() (WatchConditionsResponsePageTokenChange_FieldPath, bool) {
	res, ok := fps.subPath.(WatchConditionsResponsePageTokenChange_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source WatchConditionsResponse
func (fps *WatchConditionsResponse_FieldSubPath) Get(source *WatchConditionsResponse) (values []interface{}) {
	switch fps.selector {
	case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		values = append(values, fps.subPath.GetRaw(source.GetPageTokenChange())...)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fps.selector))
	}
	return
}

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

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

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

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

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

func (fps *WatchConditionsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*WatchConditionsResponse))
}

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

func (fps *WatchConditionsResponse_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&WatchConditionsResponse_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *WatchConditionsResponse_FieldSubPath) WithIValue(value interface{}) WatchConditionsResponse_FieldPathValue {
	return &WatchConditionsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *WatchConditionsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) WatchConditionsResponse_FieldPathArrayOfValues {
	return &WatchConditionsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *WatchConditionsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) WatchConditionsResponse_FieldPathArrayItemValue {
	return &WatchConditionsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParseWatchConditionsResponse_FieldPathValue(pathStr, valueStr string) (WatchConditionsResponse_FieldPathValue, error) {
	fp, err := ParseWatchConditionsResponse_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 WatchConditionsResponse field path value from %s: %v", valueStr, err)
	}
	return fpv.(WatchConditionsResponse_FieldPathValue), nil
}

func MustParseWatchConditionsResponse_FieldPathValue(pathStr, valueStr string) WatchConditionsResponse_FieldPathValue {
	fpv, err := ParseWatchConditionsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConditionsResponse_FieldTerminalPathValue struct {
	WatchConditionsResponse_FieldTerminalPath
	value interface{}
}

var _ WatchConditionsResponse_FieldPathValue = (*WatchConditionsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchConditionsResponse' as interface{}
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) AsConditionChangesValue() ([]*condition.ConditionChange, bool) {
	res, ok := fpv.value.([]*condition.ConditionChange)
	return res, ok
}
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) AsIsCurrentValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) AsPageTokenChangeValue() (*WatchConditionsResponse_PageTokenChange, bool) {
	res, ok := fpv.value.(*WatchConditionsResponse_PageTokenChange)
	return res, ok
}
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) AsSnapshotSizeValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) AsIsSoftResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) AsIsHardResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object WatchConditionsResponse
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) SetTo(target **WatchConditionsResponse) {
	if *target == nil {
		*target = new(WatchConditionsResponse)
	}
	switch fpv.selector {
	case WatchConditionsResponse_FieldPathSelectorConditionChanges:
		(*target).ConditionChanges = fpv.value.([]*condition.ConditionChange)
	case WatchConditionsResponse_FieldPathSelectorIsCurrent:
		(*target).IsCurrent = fpv.value.(bool)
	case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		(*target).PageTokenChange = fpv.value.(*WatchConditionsResponse_PageTokenChange)
	case WatchConditionsResponse_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchConditionsResponse_FieldPathSelectorSnapshotSize:
		(*target).SnapshotSize = fpv.value.(int64)
	case WatchConditionsResponse_FieldPathSelectorIsSoftReset:
		(*target).IsSoftReset = fpv.value.(bool)
	case WatchConditionsResponse_FieldPathSelectorIsHardReset:
		(*target).IsHardReset = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchConditionsResponse_FieldTerminalPathValue' with the value under path in 'WatchConditionsResponse'.
func (fpv *WatchConditionsResponse_FieldTerminalPathValue) CompareWith(source *WatchConditionsResponse) (int, bool) {
	switch fpv.selector {
	case WatchConditionsResponse_FieldPathSelectorConditionChanges:
		return 0, false
	case WatchConditionsResponse_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 WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		return 0, false
	case WatchConditionsResponse_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 WatchConditionsResponse_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 WatchConditionsResponse_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 WatchConditionsResponse_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 WatchConditionsResponse: %d", fpv.selector))
	}
}

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

type WatchConditionsResponse_FieldSubPathValue struct {
	WatchConditionsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ WatchConditionsResponse_FieldPathValue = (*WatchConditionsResponse_FieldSubPathValue)(nil)

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

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

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

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

func (fpvs *WatchConditionsResponse_FieldSubPathValue) CompareWith(source *WatchConditionsResponse) (int, bool) {
	switch fpvs.Selector() {
	case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		return fpvs.subPathValue.(WatchConditionsResponsePageTokenChange_FieldPathValue).CompareWith(source.GetPageTokenChange())
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse: %d", fpvs.Selector()))
	}
}

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

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

// ParseWatchConditionsResponse_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchConditionsResponse_FieldPathArrayItemValue(pathStr, valueStr string) (WatchConditionsResponse_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchConditionsResponse_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 WatchConditionsResponse field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(WatchConditionsResponse_FieldPathArrayItemValue), nil
}

func MustParseWatchConditionsResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchConditionsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConditionsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConditionsResponse_FieldTerminalPathArrayItemValue struct {
	WatchConditionsResponse_FieldTerminalPath
	value interface{}
}

var _ WatchConditionsResponse_FieldPathArrayItemValue = (*WatchConditionsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchConditionsResponse as interface{}
func (fpaiv *WatchConditionsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *WatchConditionsResponse_FieldTerminalPathArrayItemValue) AsConditionChangesItemValue() (*condition.ConditionChange, bool) {
	res, ok := fpaiv.value.(*condition.ConditionChange)
	return res, ok
}

func (fpaiv *WatchConditionsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConditionsResponse) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'WatchConditionsResponse'
func (fpaiv *WatchConditionsResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConditionsResponse) bool {
	slice := fpaiv.WatchConditionsResponse_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type WatchConditionsResponse_FieldSubPathArrayItemValue struct {
	WatchConditionsResponse_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// WatchConditionsResponse_FieldPathArrayOfValues allows storing slice of values for WatchConditionsResponse fields according to their type
type WatchConditionsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchConditionsResponse_FieldPath
}

func ParseWatchConditionsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchConditionsResponse_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchConditionsResponse_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 WatchConditionsResponse field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(WatchConditionsResponse_FieldPathArrayOfValues), nil
}

func MustParseWatchConditionsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConditionsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConditionsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConditionsResponse_FieldTerminalPathArrayOfValues struct {
	WatchConditionsResponse_FieldTerminalPath
	values interface{}
}

var _ WatchConditionsResponse_FieldPathArrayOfValues = (*WatchConditionsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConditionsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConditionsResponse_FieldPathSelectorConditionChanges:
		for _, v := range fpaov.values.([][]*condition.ConditionChange) {
			values = append(values, v)
		}
	case WatchConditionsResponse_FieldPathSelectorIsCurrent:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchConditionsResponse_FieldPathSelectorPageTokenChange:
		for _, v := range fpaov.values.([]*WatchConditionsResponse_PageTokenChange) {
			values = append(values, v)
		}
	case WatchConditionsResponse_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchConditionsResponse_FieldPathSelectorSnapshotSize:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case WatchConditionsResponse_FieldPathSelectorIsSoftReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchConditionsResponse_FieldPathSelectorIsHardReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConditionsResponse_FieldTerminalPathArrayOfValues) AsConditionChangesArrayOfValues() ([][]*condition.ConditionChange, bool) {
	res, ok := fpaov.values.([][]*condition.ConditionChange)
	return res, ok
}
func (fpaov *WatchConditionsResponse_FieldTerminalPathArrayOfValues) AsIsCurrentArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchConditionsResponse_FieldTerminalPathArrayOfValues) AsPageTokenChangeArrayOfValues() ([]*WatchConditionsResponse_PageTokenChange, bool) {
	res, ok := fpaov.values.([]*WatchConditionsResponse_PageTokenChange)
	return res, ok
}
func (fpaov *WatchConditionsResponse_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchConditionsResponse_FieldTerminalPathArrayOfValues) AsSnapshotSizeArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *WatchConditionsResponse_FieldTerminalPathArrayOfValues) AsIsSoftResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchConditionsResponse_FieldTerminalPathArrayOfValues) AsIsHardResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type WatchConditionsResponse_FieldSubPathArrayOfValues struct {
	WatchConditionsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ WatchConditionsResponse_FieldPathArrayOfValues = (*WatchConditionsResponse_FieldSubPathArrayOfValues)(nil)

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

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

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

type WatchConditionsResponsePageTokenChange_FieldPathSelector int32

const (
	WatchConditionsResponsePageTokenChange_FieldPathSelectorPrevPageToken WatchConditionsResponsePageTokenChange_FieldPathSelector = 0
	WatchConditionsResponsePageTokenChange_FieldPathSelectorNextPageToken WatchConditionsResponsePageTokenChange_FieldPathSelector = 1
)

func (s WatchConditionsResponsePageTokenChange_FieldPathSelector) String() string {
	switch s {
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return "next_page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse_PageTokenChange: %d", s))
	}
}

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

func ParseWatchConditionsResponsePageTokenChange_FieldPath(rawField string) (WatchConditionsResponsePageTokenChange_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConditionsResponsePageTokenChange_FieldPath(fp)
}

func MustParseWatchConditionsResponsePageTokenChange_FieldPath(rawField string) WatchConditionsResponsePageTokenChange_FieldPath {
	fp, err := ParseWatchConditionsResponsePageTokenChange_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConditionsResponsePageTokenChange_FieldTerminalPath struct {
	selector WatchConditionsResponsePageTokenChange_FieldPathSelector
}

var _ WatchConditionsResponsePageTokenChange_FieldPath = (*WatchConditionsResponsePageTokenChange_FieldTerminalPath)(nil)

func (fp *WatchConditionsResponsePageTokenChange_FieldTerminalPath) Selector() WatchConditionsResponsePageTokenChange_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchConditionsResponsePageTokenChange_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return (*condition.PagerCursor)(nil)
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return (*condition.PagerCursor)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchConditionsResponsePageTokenChange_FieldTerminalPath) ClearValue(item *WatchConditionsResponse_PageTokenChange) {
	if item != nil {
		switch fp.selector {
		case WatchConditionsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case WatchConditionsResponsePageTokenChange_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse_PageTokenChange: %d", fp.selector))
		}
	}
}

func (fp *WatchConditionsResponsePageTokenChange_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConditionsResponse_PageTokenChange))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchConditionsResponsePageTokenChange_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchConditionsResponsePageTokenChange_FieldPathSelectorPrevPageToken ||
		fp.selector == WatchConditionsResponsePageTokenChange_FieldPathSelectorNextPageToken
}

func (fp *WatchConditionsResponsePageTokenChange_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *WatchConditionsResponsePageTokenChange_FieldTerminalPath) WithIValue(value interface{}) WatchConditionsResponsePageTokenChange_FieldPathValue {
	switch fp.selector {
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchConditionsResponsePageTokenChange_FieldTerminalPathValue{WatchConditionsResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*condition.PagerCursor)}
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchConditionsResponsePageTokenChange_FieldTerminalPathValue{WatchConditionsResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*condition.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse_PageTokenChange: %d", fp.selector))
	}
}

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

func (fp *WatchConditionsResponsePageTokenChange_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConditionsResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov := &WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchConditionsResponsePageTokenChange_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchConditionsResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*condition.PagerCursor)}
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchConditionsResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*condition.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse_PageTokenChange: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParseWatchConditionsResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) (WatchConditionsResponsePageTokenChange_FieldPathValue, error) {
	fp, err := ParseWatchConditionsResponsePageTokenChange_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.(WatchConditionsResponsePageTokenChange_FieldPathValue), nil
}

func MustParseWatchConditionsResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) WatchConditionsResponsePageTokenChange_FieldPathValue {
	fpv, err := ParseWatchConditionsResponsePageTokenChange_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConditionsResponsePageTokenChange_FieldTerminalPathValue struct {
	WatchConditionsResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchConditionsResponsePageTokenChange_FieldPathValue = (*WatchConditionsResponsePageTokenChange_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object PageTokenChange
func (fpv *WatchConditionsResponsePageTokenChange_FieldTerminalPathValue) SetTo(target **WatchConditionsResponse_PageTokenChange) {
	if *target == nil {
		*target = new(WatchConditionsResponse_PageTokenChange)
	}
	switch fpv.selector {
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*condition.PagerCursor)
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*condition.PagerCursor)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConditionsResponse_PageTokenChange: %d", fpv.selector))
	}
}

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

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

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

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

// ParseWatchConditionsResponsePageTokenChange_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchConditionsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) (WatchConditionsResponsePageTokenChange_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchConditionsResponsePageTokenChange_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.(WatchConditionsResponsePageTokenChange_FieldPathArrayItemValue), nil
}

func MustParseWatchConditionsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) WatchConditionsResponsePageTokenChange_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConditionsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayItemValue struct {
	WatchConditionsResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchConditionsResponsePageTokenChange_FieldPathArrayItemValue = (*WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConditionsResponse_PageTokenChange) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'PageTokenChange'
func (fpaiv *WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConditionsResponse_PageTokenChange) bool {
	slice := fpaiv.WatchConditionsResponsePageTokenChange_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

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

func ParseWatchConditionsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchConditionsResponsePageTokenChange_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchConditionsResponsePageTokenChange_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.(WatchConditionsResponsePageTokenChange_FieldPathArrayOfValues), nil
}

func MustParseWatchConditionsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConditionsResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConditionsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayOfValues struct {
	WatchConditionsResponsePageTokenChange_FieldTerminalPath
	values interface{}
}

var _ WatchConditionsResponsePageTokenChange_FieldPathArrayOfValues = (*WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*condition.PagerCursor) {
			values = append(values, v)
		}
	case WatchConditionsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*condition.PagerCursor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*condition.PagerCursor, bool) {
	res, ok := fpaov.values.([]*condition.PagerCursor)
	return res, ok
}
func (fpaov *WatchConditionsResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*condition.PagerCursor, bool) {
	res, ok := fpaov.values.([]*condition.PagerCursor)
	return res, ok
}

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

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

type CreateConditionRequest_FieldPathSelector int32

const (
	CreateConditionRequest_FieldPathSelectorParent    CreateConditionRequest_FieldPathSelector = 0
	CreateConditionRequest_FieldPathSelectorCondition CreateConditionRequest_FieldPathSelector = 1
)

func (s CreateConditionRequest_FieldPathSelector) String() string {
	switch s {
	case CreateConditionRequest_FieldPathSelectorParent:
		return "parent"
	case CreateConditionRequest_FieldPathSelectorCondition:
		return "condition"
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", s))
	}
}

func BuildCreateConditionRequest_FieldPath(fp gotenobject.RawFieldPath) (CreateConditionRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreateConditionRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &CreateConditionRequest_FieldTerminalPath{selector: CreateConditionRequest_FieldPathSelectorParent}, nil
		case "condition":
			return &CreateConditionRequest_FieldTerminalPath{selector: CreateConditionRequest_FieldPathSelectorCondition}, nil
		}
	} else {
		switch fp[0] {
		case "condition":
			if subpath, err := condition.BuildCondition_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateConditionRequest_FieldSubPath{selector: CreateConditionRequest_FieldPathSelectorCondition, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreateConditionRequest", fp)
}

func ParseCreateConditionRequest_FieldPath(rawField string) (CreateConditionRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreateConditionRequest_FieldPath(fp)
}

func MustParseCreateConditionRequest_FieldPath(rawField string) CreateConditionRequest_FieldPath {
	fp, err := ParseCreateConditionRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreateConditionRequest_FieldTerminalPath struct {
	selector CreateConditionRequest_FieldPathSelector
}

var _ CreateConditionRequest_FieldPath = (*CreateConditionRequest_FieldTerminalPath)(nil)

func (fp *CreateConditionRequest_FieldTerminalPath) Selector() CreateConditionRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *CreateConditionRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreateConditionRequest_FieldPathSelectorParent:
		return (*condition.ParentReference)(nil)
	case CreateConditionRequest_FieldPathSelectorCondition:
		return (*condition.Condition)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fp.selector))
	}
}

func (fp *CreateConditionRequest_FieldTerminalPath) ClearValue(item *CreateConditionRequest) {
	if item != nil {
		switch fp.selector {
		case CreateConditionRequest_FieldPathSelectorParent:
			item.Parent = nil
		case CreateConditionRequest_FieldPathSelectorCondition:
			item.Condition = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fp.selector))
		}
	}
}

func (fp *CreateConditionRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreateConditionRequest))
}

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

func (fp *CreateConditionRequest_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *CreateConditionRequest_FieldTerminalPath) WithIValue(value interface{}) CreateConditionRequest_FieldPathValue {
	switch fp.selector {
	case CreateConditionRequest_FieldPathSelectorParent:
		return &CreateConditionRequest_FieldTerminalPathValue{CreateConditionRequest_FieldTerminalPath: *fp, value: value.(*condition.ParentReference)}
	case CreateConditionRequest_FieldPathSelectorCondition:
		return &CreateConditionRequest_FieldTerminalPathValue{CreateConditionRequest_FieldTerminalPath: *fp, value: value.(*condition.Condition)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fp.selector))
	}
}

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

func (fp *CreateConditionRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreateConditionRequest_FieldPathArrayOfValues {
	fpaov := &CreateConditionRequest_FieldTerminalPathArrayOfValues{CreateConditionRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreateConditionRequest_FieldPathSelectorParent:
		return &CreateConditionRequest_FieldTerminalPathArrayOfValues{CreateConditionRequest_FieldTerminalPath: *fp, values: values.([]*condition.ParentReference)}
	case CreateConditionRequest_FieldPathSelectorCondition:
		return &CreateConditionRequest_FieldTerminalPathArrayOfValues{CreateConditionRequest_FieldTerminalPath: *fp, values: values.([]*condition.Condition)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type CreateConditionRequest_FieldSubPath struct {
	selector CreateConditionRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreateConditionRequest_FieldPath = (*CreateConditionRequest_FieldSubPath)(nil)

func (fps *CreateConditionRequest_FieldSubPath) Selector() CreateConditionRequest_FieldPathSelector {
	return fps.selector
}
func (fps *CreateConditionRequest_FieldSubPath) AsConditionSubPath() (condition.Condition_FieldPath, bool) {
	res, ok := fps.subPath.(condition.Condition_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source CreateConditionRequest
func (fps *CreateConditionRequest_FieldSubPath) Get(source *CreateConditionRequest) (values []interface{}) {
	switch fps.selector {
	case CreateConditionRequest_FieldPathSelectorCondition:
		values = append(values, fps.subPath.GetRaw(source.GetCondition())...)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fps.selector))
	}
	return
}

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

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

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

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

func (fps *CreateConditionRequest_FieldSubPath) ClearValue(item *CreateConditionRequest) {
	if item != nil {
		switch fps.selector {
		case CreateConditionRequest_FieldPathSelectorCondition:
			fps.subPath.ClearValueRaw(item.Condition)
		default:
			panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fps.selector))
		}
	}
}

func (fps *CreateConditionRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreateConditionRequest))
}

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

func (fps *CreateConditionRequest_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&CreateConditionRequest_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *CreateConditionRequest_FieldSubPath) WithIValue(value interface{}) CreateConditionRequest_FieldPathValue {
	return &CreateConditionRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *CreateConditionRequest_FieldSubPath) WithIArrayOfValues(values interface{}) CreateConditionRequest_FieldPathArrayOfValues {
	return &CreateConditionRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *CreateConditionRequest_FieldSubPath) WithIArrayItemValue(value interface{}) CreateConditionRequest_FieldPathArrayItemValue {
	return &CreateConditionRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParseCreateConditionRequest_FieldPathValue(pathStr, valueStr string) (CreateConditionRequest_FieldPathValue, error) {
	fp, err := ParseCreateConditionRequest_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 CreateConditionRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(CreateConditionRequest_FieldPathValue), nil
}

func MustParseCreateConditionRequest_FieldPathValue(pathStr, valueStr string) CreateConditionRequest_FieldPathValue {
	fpv, err := ParseCreateConditionRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreateConditionRequest_FieldTerminalPathValue struct {
	CreateConditionRequest_FieldTerminalPath
	value interface{}
}

var _ CreateConditionRequest_FieldPathValue = (*CreateConditionRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreateConditionRequest' as interface{}
func (fpv *CreateConditionRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreateConditionRequest_FieldTerminalPathValue) AsParentValue() (*condition.ParentReference, bool) {
	res, ok := fpv.value.(*condition.ParentReference)
	return res, ok
}
func (fpv *CreateConditionRequest_FieldTerminalPathValue) AsConditionValue() (*condition.Condition, bool) {
	res, ok := fpv.value.(*condition.Condition)
	return res, ok
}

// SetTo stores value for selected field for object CreateConditionRequest
func (fpv *CreateConditionRequest_FieldTerminalPathValue) SetTo(target **CreateConditionRequest) {
	if *target == nil {
		*target = new(CreateConditionRequest)
	}
	switch fpv.selector {
	case CreateConditionRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*condition.ParentReference)
	case CreateConditionRequest_FieldPathSelectorCondition:
		(*target).Condition = fpv.value.(*condition.Condition)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'CreateConditionRequest_FieldTerminalPathValue' with the value under path in 'CreateConditionRequest'.
func (fpv *CreateConditionRequest_FieldTerminalPathValue) CompareWith(source *CreateConditionRequest) (int, bool) {
	switch fpv.selector {
	case CreateConditionRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*condition.ParentReference)
		rightValue := source.GetParent()
		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 CreateConditionRequest_FieldPathSelectorCondition:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fpv.selector))
	}
}

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

type CreateConditionRequest_FieldSubPathValue struct {
	CreateConditionRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreateConditionRequest_FieldPathValue = (*CreateConditionRequest_FieldSubPathValue)(nil)

func (fpvs *CreateConditionRequest_FieldSubPathValue) AsConditionPathValue() (condition.Condition_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(condition.Condition_FieldPathValue)
	return res, ok
}

func (fpvs *CreateConditionRequest_FieldSubPathValue) SetTo(target **CreateConditionRequest) {
	if *target == nil {
		*target = new(CreateConditionRequest)
	}
	switch fpvs.Selector() {
	case CreateConditionRequest_FieldPathSelectorCondition:
		fpvs.subPathValue.(condition.Condition_FieldPathValue).SetTo(&(*target).Condition)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *CreateConditionRequest_FieldSubPathValue) CompareWith(source *CreateConditionRequest) (int, bool) {
	switch fpvs.Selector() {
	case CreateConditionRequest_FieldPathSelectorCondition:
		return fpvs.subPathValue.(condition.Condition_FieldPathValue).CompareWith(source.GetCondition())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConditionRequest: %d", fpvs.Selector()))
	}
}

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

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

// ParseCreateConditionRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseCreateConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) (CreateConditionRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseCreateConditionRequest_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 CreateConditionRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(CreateConditionRequest_FieldPathArrayItemValue), nil
}

func MustParseCreateConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) CreateConditionRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseCreateConditionRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreateConditionRequest_FieldTerminalPathArrayItemValue struct {
	CreateConditionRequest_FieldTerminalPath
	value interface{}
}

var _ CreateConditionRequest_FieldPathArrayItemValue = (*CreateConditionRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *CreateConditionRequest_FieldTerminalPathArrayItemValue) GetSingle(source *CreateConditionRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'CreateConditionRequest'
func (fpaiv *CreateConditionRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *CreateConditionRequest) bool {
	slice := fpaiv.CreateConditionRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type CreateConditionRequest_FieldSubPathArrayItemValue struct {
	CreateConditionRequest_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *CreateConditionRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *CreateConditionRequest_FieldSubPathArrayItemValue) AsConditionPathItemValue() (condition.Condition_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(condition.Condition_FieldPathArrayItemValue)
	return res, ok
}

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

// CreateConditionRequest_FieldPathArrayOfValues allows storing slice of values for CreateConditionRequest fields according to their type
type CreateConditionRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreateConditionRequest_FieldPath
}

func ParseCreateConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (CreateConditionRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseCreateConditionRequest_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 CreateConditionRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(CreateConditionRequest_FieldPathArrayOfValues), nil
}

func MustParseCreateConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) CreateConditionRequest_FieldPathArrayOfValues {
	fpaov, err := ParseCreateConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreateConditionRequest_FieldTerminalPathArrayOfValues struct {
	CreateConditionRequest_FieldTerminalPath
	values interface{}
}

var _ CreateConditionRequest_FieldPathArrayOfValues = (*CreateConditionRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreateConditionRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreateConditionRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*condition.ParentReference) {
			values = append(values, v)
		}
	case CreateConditionRequest_FieldPathSelectorCondition:
		for _, v := range fpaov.values.([]*condition.Condition) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreateConditionRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*condition.ParentReference, bool) {
	res, ok := fpaov.values.([]*condition.ParentReference)
	return res, ok
}
func (fpaov *CreateConditionRequest_FieldTerminalPathArrayOfValues) AsConditionArrayOfValues() ([]*condition.Condition, bool) {
	res, ok := fpaov.values.([]*condition.Condition)
	return res, ok
}

type CreateConditionRequest_FieldSubPathArrayOfValues struct {
	CreateConditionRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreateConditionRequest_FieldPathArrayOfValues = (*CreateConditionRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *CreateConditionRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *CreateConditionRequest_FieldSubPathArrayOfValues) AsConditionPathArrayOfValues() (condition.Condition_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(condition.Condition_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateConditionRequest_FieldPathSelector int32

const (
	UpdateConditionRequest_FieldPathSelectorCondition    UpdateConditionRequest_FieldPathSelector = 0
	UpdateConditionRequest_FieldPathSelectorUpdateMask   UpdateConditionRequest_FieldPathSelector = 1
	UpdateConditionRequest_FieldPathSelectorCas          UpdateConditionRequest_FieldPathSelector = 2
	UpdateConditionRequest_FieldPathSelectorAllowMissing UpdateConditionRequest_FieldPathSelector = 3
)

func (s UpdateConditionRequest_FieldPathSelector) String() string {
	switch s {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		return "condition"
	case UpdateConditionRequest_FieldPathSelectorUpdateMask:
		return "update_mask"
	case UpdateConditionRequest_FieldPathSelectorCas:
		return "cas"
	case UpdateConditionRequest_FieldPathSelectorAllowMissing:
		return "allow_missing"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", s))
	}
}

func BuildUpdateConditionRequest_FieldPath(fp gotenobject.RawFieldPath) (UpdateConditionRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateConditionRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "condition":
			return &UpdateConditionRequest_FieldTerminalPath{selector: UpdateConditionRequest_FieldPathSelectorCondition}, nil
		case "update_mask", "updateMask", "update-mask":
			return &UpdateConditionRequest_FieldTerminalPath{selector: UpdateConditionRequest_FieldPathSelectorUpdateMask}, nil
		case "cas":
			return &UpdateConditionRequest_FieldTerminalPath{selector: UpdateConditionRequest_FieldPathSelectorCas}, nil
		case "allow_missing", "allowMissing", "allow-missing":
			return &UpdateConditionRequest_FieldTerminalPath{selector: UpdateConditionRequest_FieldPathSelectorAllowMissing}, nil
		}
	} else {
		switch fp[0] {
		case "condition":
			if subpath, err := condition.BuildCondition_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateConditionRequest_FieldSubPath{selector: UpdateConditionRequest_FieldPathSelectorCondition, subPath: subpath}, nil
			}
		case "cas":
			if subpath, err := BuildUpdateConditionRequestCAS_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateConditionRequest_FieldSubPath{selector: UpdateConditionRequest_FieldPathSelectorCas, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateConditionRequest", fp)
}

func ParseUpdateConditionRequest_FieldPath(rawField string) (UpdateConditionRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateConditionRequest_FieldPath(fp)
}

func MustParseUpdateConditionRequest_FieldPath(rawField string) UpdateConditionRequest_FieldPath {
	fp, err := ParseUpdateConditionRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateConditionRequest_FieldTerminalPath struct {
	selector UpdateConditionRequest_FieldPathSelector
}

var _ UpdateConditionRequest_FieldPath = (*UpdateConditionRequest_FieldTerminalPath)(nil)

func (fp *UpdateConditionRequest_FieldTerminalPath) Selector() UpdateConditionRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source UpdateConditionRequest
func (fp *UpdateConditionRequest_FieldTerminalPath) Get(source *UpdateConditionRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case UpdateConditionRequest_FieldPathSelectorCondition:
			if source.Condition != nil {
				values = append(values, source.Condition)
			}
		case UpdateConditionRequest_FieldPathSelectorUpdateMask:
			if source.UpdateMask != nil {
				values = append(values, source.UpdateMask)
			}
		case UpdateConditionRequest_FieldPathSelectorCas:
			if source.Cas != nil {
				values = append(values, source.Cas)
			}
		case UpdateConditionRequest_FieldPathSelectorAllowMissing:
			values = append(values, source.AllowMissing)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source UpdateConditionRequest
func (fp *UpdateConditionRequest_FieldTerminalPath) GetSingle(source *UpdateConditionRequest) (interface{}, bool) {
	switch fp.selector {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		res := source.GetCondition()
		return res, res != nil
	case UpdateConditionRequest_FieldPathSelectorUpdateMask:
		res := source.GetUpdateMask()
		return res, res != nil
	case UpdateConditionRequest_FieldPathSelectorCas:
		res := source.GetCas()
		return res, res != nil
	case UpdateConditionRequest_FieldPathSelectorAllowMissing:
		return source.GetAllowMissing(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *UpdateConditionRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		return (*condition.Condition)(nil)
	case UpdateConditionRequest_FieldPathSelectorUpdateMask:
		return (*condition.Condition_FieldMask)(nil)
	case UpdateConditionRequest_FieldPathSelectorCas:
		return (*UpdateConditionRequest_CAS)(nil)
	case UpdateConditionRequest_FieldPathSelectorAllowMissing:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fp.selector))
	}
}

func (fp *UpdateConditionRequest_FieldTerminalPath) ClearValue(item *UpdateConditionRequest) {
	if item != nil {
		switch fp.selector {
		case UpdateConditionRequest_FieldPathSelectorCondition:
			item.Condition = nil
		case UpdateConditionRequest_FieldPathSelectorUpdateMask:
			item.UpdateMask = nil
		case UpdateConditionRequest_FieldPathSelectorCas:
			item.Cas = nil
		case UpdateConditionRequest_FieldPathSelectorAllowMissing:
			item.AllowMissing = false
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fp.selector))
		}
	}
}

func (fp *UpdateConditionRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateConditionRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *UpdateConditionRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == UpdateConditionRequest_FieldPathSelectorUpdateMask ||
		fp.selector == UpdateConditionRequest_FieldPathSelectorAllowMissing
}

func (fp *UpdateConditionRequest_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *UpdateConditionRequest_FieldTerminalPath) WithIValue(value interface{}) UpdateConditionRequest_FieldPathValue {
	switch fp.selector {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		return &UpdateConditionRequest_FieldTerminalPathValue{UpdateConditionRequest_FieldTerminalPath: *fp, value: value.(*condition.Condition)}
	case UpdateConditionRequest_FieldPathSelectorUpdateMask:
		return &UpdateConditionRequest_FieldTerminalPathValue{UpdateConditionRequest_FieldTerminalPath: *fp, value: value.(*condition.Condition_FieldMask)}
	case UpdateConditionRequest_FieldPathSelectorCas:
		return &UpdateConditionRequest_FieldTerminalPathValue{UpdateConditionRequest_FieldTerminalPath: *fp, value: value.(*UpdateConditionRequest_CAS)}
	case UpdateConditionRequest_FieldPathSelectorAllowMissing:
		return &UpdateConditionRequest_FieldTerminalPathValue{UpdateConditionRequest_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fp.selector))
	}
}

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

func (fp *UpdateConditionRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateConditionRequest_FieldPathArrayOfValues {
	fpaov := &UpdateConditionRequest_FieldTerminalPathArrayOfValues{UpdateConditionRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		return &UpdateConditionRequest_FieldTerminalPathArrayOfValues{UpdateConditionRequest_FieldTerminalPath: *fp, values: values.([]*condition.Condition)}
	case UpdateConditionRequest_FieldPathSelectorUpdateMask:
		return &UpdateConditionRequest_FieldTerminalPathArrayOfValues{UpdateConditionRequest_FieldTerminalPath: *fp, values: values.([]*condition.Condition_FieldMask)}
	case UpdateConditionRequest_FieldPathSelectorCas:
		return &UpdateConditionRequest_FieldTerminalPathArrayOfValues{UpdateConditionRequest_FieldTerminalPath: *fp, values: values.([]*UpdateConditionRequest_CAS)}
	case UpdateConditionRequest_FieldPathSelectorAllowMissing:
		return &UpdateConditionRequest_FieldTerminalPathArrayOfValues{UpdateConditionRequest_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateConditionRequest_FieldSubPath struct {
	selector UpdateConditionRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateConditionRequest_FieldPath = (*UpdateConditionRequest_FieldSubPath)(nil)

func (fps *UpdateConditionRequest_FieldSubPath) Selector() UpdateConditionRequest_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateConditionRequest_FieldSubPath) AsConditionSubPath() (condition.Condition_FieldPath, bool) {
	res, ok := fps.subPath.(condition.Condition_FieldPath)
	return res, ok
}
func (fps *UpdateConditionRequest_FieldSubPath) AsCasSubPath() (UpdateConditionRequestCAS_FieldPath, bool) {
	res, ok := fps.subPath.(UpdateConditionRequestCAS_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source UpdateConditionRequest
func (fps *UpdateConditionRequest_FieldSubPath) Get(source *UpdateConditionRequest) (values []interface{}) {
	switch fps.selector {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		values = append(values, fps.subPath.GetRaw(source.GetCondition())...)
	case UpdateConditionRequest_FieldPathSelectorCas:
		values = append(values, fps.subPath.GetRaw(source.GetCas())...)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fps.selector))
	}
	return
}

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

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

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

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

func (fps *UpdateConditionRequest_FieldSubPath) ClearValue(item *UpdateConditionRequest) {
	if item != nil {
		switch fps.selector {
		case UpdateConditionRequest_FieldPathSelectorCondition:
			fps.subPath.ClearValueRaw(item.Condition)
		case UpdateConditionRequest_FieldPathSelectorCas:
			fps.subPath.ClearValueRaw(item.Cas)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fps.selector))
		}
	}
}

func (fps *UpdateConditionRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateConditionRequest))
}

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

func (fps *UpdateConditionRequest_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&UpdateConditionRequest_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *UpdateConditionRequest_FieldSubPath) WithIValue(value interface{}) UpdateConditionRequest_FieldPathValue {
	return &UpdateConditionRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateConditionRequest_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateConditionRequest_FieldPathArrayOfValues {
	return &UpdateConditionRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateConditionRequest_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateConditionRequest_FieldPathArrayItemValue {
	return &UpdateConditionRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParseUpdateConditionRequest_FieldPathValue(pathStr, valueStr string) (UpdateConditionRequest_FieldPathValue, error) {
	fp, err := ParseUpdateConditionRequest_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 UpdateConditionRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(UpdateConditionRequest_FieldPathValue), nil
}

func MustParseUpdateConditionRequest_FieldPathValue(pathStr, valueStr string) UpdateConditionRequest_FieldPathValue {
	fpv, err := ParseUpdateConditionRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateConditionRequest_FieldTerminalPathValue struct {
	UpdateConditionRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateConditionRequest_FieldPathValue = (*UpdateConditionRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'UpdateConditionRequest' as interface{}
func (fpv *UpdateConditionRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateConditionRequest_FieldTerminalPathValue) AsConditionValue() (*condition.Condition, bool) {
	res, ok := fpv.value.(*condition.Condition)
	return res, ok
}
func (fpv *UpdateConditionRequest_FieldTerminalPathValue) AsUpdateMaskValue() (*condition.Condition_FieldMask, bool) {
	res, ok := fpv.value.(*condition.Condition_FieldMask)
	return res, ok
}
func (fpv *UpdateConditionRequest_FieldTerminalPathValue) AsCasValue() (*UpdateConditionRequest_CAS, bool) {
	res, ok := fpv.value.(*UpdateConditionRequest_CAS)
	return res, ok
}
func (fpv *UpdateConditionRequest_FieldTerminalPathValue) AsAllowMissingValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object UpdateConditionRequest
func (fpv *UpdateConditionRequest_FieldTerminalPathValue) SetTo(target **UpdateConditionRequest) {
	if *target == nil {
		*target = new(UpdateConditionRequest)
	}
	switch fpv.selector {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		(*target).Condition = fpv.value.(*condition.Condition)
	case UpdateConditionRequest_FieldPathSelectorUpdateMask:
		(*target).UpdateMask = fpv.value.(*condition.Condition_FieldMask)
	case UpdateConditionRequest_FieldPathSelectorCas:
		(*target).Cas = fpv.value.(*UpdateConditionRequest_CAS)
	case UpdateConditionRequest_FieldPathSelectorAllowMissing:
		(*target).AllowMissing = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'UpdateConditionRequest_FieldTerminalPathValue' with the value under path in 'UpdateConditionRequest'.
func (fpv *UpdateConditionRequest_FieldTerminalPathValue) CompareWith(source *UpdateConditionRequest) (int, bool) {
	switch fpv.selector {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		return 0, false
	case UpdateConditionRequest_FieldPathSelectorUpdateMask:
		return 0, false
	case UpdateConditionRequest_FieldPathSelectorCas:
		return 0, false
	case UpdateConditionRequest_FieldPathSelectorAllowMissing:
		leftValue := fpv.value.(bool)
		rightValue := source.GetAllowMissing()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fpv.selector))
	}
}

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

type UpdateConditionRequest_FieldSubPathValue struct {
	UpdateConditionRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateConditionRequest_FieldPathValue = (*UpdateConditionRequest_FieldSubPathValue)(nil)

func (fpvs *UpdateConditionRequest_FieldSubPathValue) AsConditionPathValue() (condition.Condition_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(condition.Condition_FieldPathValue)
	return res, ok
}
func (fpvs *UpdateConditionRequest_FieldSubPathValue) AsCasPathValue() (UpdateConditionRequestCAS_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(UpdateConditionRequestCAS_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateConditionRequest_FieldSubPathValue) SetTo(target **UpdateConditionRequest) {
	if *target == nil {
		*target = new(UpdateConditionRequest)
	}
	switch fpvs.Selector() {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		fpvs.subPathValue.(condition.Condition_FieldPathValue).SetTo(&(*target).Condition)
	case UpdateConditionRequest_FieldPathSelectorCas:
		fpvs.subPathValue.(UpdateConditionRequestCAS_FieldPathValue).SetTo(&(*target).Cas)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateConditionRequest_FieldSubPathValue) CompareWith(source *UpdateConditionRequest) (int, bool) {
	switch fpvs.Selector() {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		return fpvs.subPathValue.(condition.Condition_FieldPathValue).CompareWith(source.GetCondition())
	case UpdateConditionRequest_FieldPathSelectorCas:
		return fpvs.subPathValue.(UpdateConditionRequestCAS_FieldPathValue).CompareWith(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fpvs.Selector()))
	}
}

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

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

// ParseUpdateConditionRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseUpdateConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) (UpdateConditionRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseUpdateConditionRequest_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 UpdateConditionRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(UpdateConditionRequest_FieldPathArrayItemValue), nil
}

func MustParseUpdateConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) UpdateConditionRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateConditionRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateConditionRequest_FieldTerminalPathArrayItemValue struct {
	UpdateConditionRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateConditionRequest_FieldPathArrayItemValue = (*UpdateConditionRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateConditionRequest_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateConditionRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'UpdateConditionRequest'
func (fpaiv *UpdateConditionRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *UpdateConditionRequest) bool {
	slice := fpaiv.UpdateConditionRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type UpdateConditionRequest_FieldSubPathArrayItemValue struct {
	UpdateConditionRequest_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *UpdateConditionRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdateConditionRequest_FieldSubPathArrayItemValue) AsConditionPathItemValue() (condition.Condition_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(condition.Condition_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *UpdateConditionRequest_FieldSubPathArrayItemValue) AsCasPathItemValue() (UpdateConditionRequestCAS_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(UpdateConditionRequestCAS_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'UpdateConditionRequest'
func (fpaivs *UpdateConditionRequest_FieldSubPathArrayItemValue) ContainsValue(source *UpdateConditionRequest) bool {
	switch fpaivs.Selector() {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		return fpaivs.subPathItemValue.(condition.Condition_FieldPathArrayItemValue).ContainsValue(source.GetCondition())
	case UpdateConditionRequest_FieldPathSelectorCas:
		return fpaivs.subPathItemValue.(UpdateConditionRequestCAS_FieldPathArrayItemValue).ContainsValue(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest: %d", fpaivs.Selector()))
	}
}

// UpdateConditionRequest_FieldPathArrayOfValues allows storing slice of values for UpdateConditionRequest fields according to their type
type UpdateConditionRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdateConditionRequest_FieldPath
}

func ParseUpdateConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (UpdateConditionRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseUpdateConditionRequest_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 UpdateConditionRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(UpdateConditionRequest_FieldPathArrayOfValues), nil
}

func MustParseUpdateConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateConditionRequest_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateConditionRequest_FieldTerminalPathArrayOfValues struct {
	UpdateConditionRequest_FieldTerminalPath
	values interface{}
}

var _ UpdateConditionRequest_FieldPathArrayOfValues = (*UpdateConditionRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateConditionRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateConditionRequest_FieldPathSelectorCondition:
		for _, v := range fpaov.values.([]*condition.Condition) {
			values = append(values, v)
		}
	case UpdateConditionRequest_FieldPathSelectorUpdateMask:
		for _, v := range fpaov.values.([]*condition.Condition_FieldMask) {
			values = append(values, v)
		}
	case UpdateConditionRequest_FieldPathSelectorCas:
		for _, v := range fpaov.values.([]*UpdateConditionRequest_CAS) {
			values = append(values, v)
		}
	case UpdateConditionRequest_FieldPathSelectorAllowMissing:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateConditionRequest_FieldTerminalPathArrayOfValues) AsConditionArrayOfValues() ([]*condition.Condition, bool) {
	res, ok := fpaov.values.([]*condition.Condition)
	return res, ok
}
func (fpaov *UpdateConditionRequest_FieldTerminalPathArrayOfValues) AsUpdateMaskArrayOfValues() ([]*condition.Condition_FieldMask, bool) {
	res, ok := fpaov.values.([]*condition.Condition_FieldMask)
	return res, ok
}
func (fpaov *UpdateConditionRequest_FieldTerminalPathArrayOfValues) AsCasArrayOfValues() ([]*UpdateConditionRequest_CAS, bool) {
	res, ok := fpaov.values.([]*UpdateConditionRequest_CAS)
	return res, ok
}
func (fpaov *UpdateConditionRequest_FieldTerminalPathArrayOfValues) AsAllowMissingArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type UpdateConditionRequest_FieldSubPathArrayOfValues struct {
	UpdateConditionRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateConditionRequest_FieldPathArrayOfValues = (*UpdateConditionRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateConditionRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateConditionRequest_FieldSubPathArrayOfValues) AsConditionPathArrayOfValues() (condition.Condition_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(condition.Condition_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *UpdateConditionRequest_FieldSubPathArrayOfValues) AsCasPathArrayOfValues() (UpdateConditionRequestCAS_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(UpdateConditionRequestCAS_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateConditionRequestCAS_FieldPathSelector int32

const (
	UpdateConditionRequestCAS_FieldPathSelectorConditionalState UpdateConditionRequestCAS_FieldPathSelector = 0
	UpdateConditionRequestCAS_FieldPathSelectorFieldMask        UpdateConditionRequestCAS_FieldPathSelector = 1
)

func (s UpdateConditionRequestCAS_FieldPathSelector) String() string {
	switch s {
	case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
		return "conditional_state"
	case UpdateConditionRequestCAS_FieldPathSelectorFieldMask:
		return "field_mask"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest_CAS: %d", s))
	}
}

func BuildUpdateConditionRequestCAS_FieldPath(fp gotenobject.RawFieldPath) (UpdateConditionRequestCAS_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateConditionRequest_CAS")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			return &UpdateConditionRequestCAS_FieldTerminalPath{selector: UpdateConditionRequestCAS_FieldPathSelectorConditionalState}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &UpdateConditionRequestCAS_FieldTerminalPath{selector: UpdateConditionRequestCAS_FieldPathSelectorFieldMask}, nil
		}
	} else {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			if subpath, err := condition.BuildCondition_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateConditionRequestCAS_FieldSubPath{selector: UpdateConditionRequestCAS_FieldPathSelectorConditionalState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateConditionRequest_CAS", fp)
}

func ParseUpdateConditionRequestCAS_FieldPath(rawField string) (UpdateConditionRequestCAS_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateConditionRequestCAS_FieldPath(fp)
}

func MustParseUpdateConditionRequestCAS_FieldPath(rawField string) UpdateConditionRequestCAS_FieldPath {
	fp, err := ParseUpdateConditionRequestCAS_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateConditionRequestCAS_FieldTerminalPath struct {
	selector UpdateConditionRequestCAS_FieldPathSelector
}

var _ UpdateConditionRequestCAS_FieldPath = (*UpdateConditionRequestCAS_FieldTerminalPath)(nil)

func (fp *UpdateConditionRequestCAS_FieldTerminalPath) Selector() UpdateConditionRequestCAS_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *UpdateConditionRequestCAS_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
		return (*condition.Condition)(nil)
	case UpdateConditionRequestCAS_FieldPathSelectorFieldMask:
		return (*condition.Condition_FieldMask)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdateConditionRequestCAS_FieldTerminalPath) ClearValue(item *UpdateConditionRequest_CAS) {
	if item != nil {
		switch fp.selector {
		case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
			item.ConditionalState = nil
		case UpdateConditionRequestCAS_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest_CAS: %d", fp.selector))
		}
	}
}

func (fp *UpdateConditionRequestCAS_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateConditionRequest_CAS))
}

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

func (fp *UpdateConditionRequestCAS_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *UpdateConditionRequestCAS_FieldTerminalPath) WithIValue(value interface{}) UpdateConditionRequestCAS_FieldPathValue {
	switch fp.selector {
	case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateConditionRequestCAS_FieldTerminalPathValue{UpdateConditionRequestCAS_FieldTerminalPath: *fp, value: value.(*condition.Condition)}
	case UpdateConditionRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateConditionRequestCAS_FieldTerminalPathValue{UpdateConditionRequestCAS_FieldTerminalPath: *fp, value: value.(*condition.Condition_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest_CAS: %d", fp.selector))
	}
}

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

func (fp *UpdateConditionRequestCAS_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateConditionRequestCAS_FieldPathArrayOfValues {
	fpaov := &UpdateConditionRequestCAS_FieldTerminalPathArrayOfValues{UpdateConditionRequestCAS_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateConditionRequestCAS_FieldTerminalPathArrayOfValues{UpdateConditionRequestCAS_FieldTerminalPath: *fp, values: values.([]*condition.Condition)}
	case UpdateConditionRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateConditionRequestCAS_FieldTerminalPathArrayOfValues{UpdateConditionRequestCAS_FieldTerminalPath: *fp, values: values.([]*condition.Condition_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest_CAS: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateConditionRequestCAS_FieldSubPath struct {
	selector UpdateConditionRequestCAS_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateConditionRequestCAS_FieldPath = (*UpdateConditionRequestCAS_FieldSubPath)(nil)

func (fps *UpdateConditionRequestCAS_FieldSubPath) Selector() UpdateConditionRequestCAS_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateConditionRequestCAS_FieldSubPath) AsConditionalStateSubPath() (condition.Condition_FieldPath, bool) {
	res, ok := fps.subPath.(condition.Condition_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source UpdateConditionRequest_CAS
func (fps *UpdateConditionRequestCAS_FieldSubPath) Get(source *UpdateConditionRequest_CAS) (values []interface{}) {
	switch fps.selector {
	case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
		values = append(values, fps.subPath.GetRaw(source.GetConditionalState())...)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest_CAS: %d", fps.selector))
	}
	return
}

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

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

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

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

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

func (fps *UpdateConditionRequestCAS_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateConditionRequest_CAS))
}

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

func (fps *UpdateConditionRequestCAS_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&UpdateConditionRequestCAS_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *UpdateConditionRequestCAS_FieldSubPath) WithIValue(value interface{}) UpdateConditionRequestCAS_FieldPathValue {
	return &UpdateConditionRequestCAS_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateConditionRequestCAS_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateConditionRequestCAS_FieldPathArrayOfValues {
	return &UpdateConditionRequestCAS_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateConditionRequestCAS_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateConditionRequestCAS_FieldPathArrayItemValue {
	return &UpdateConditionRequestCAS_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParseUpdateConditionRequestCAS_FieldPathValue(pathStr, valueStr string) (UpdateConditionRequestCAS_FieldPathValue, error) {
	fp, err := ParseUpdateConditionRequestCAS_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.(UpdateConditionRequestCAS_FieldPathValue), nil
}

func MustParseUpdateConditionRequestCAS_FieldPathValue(pathStr, valueStr string) UpdateConditionRequestCAS_FieldPathValue {
	fpv, err := ParseUpdateConditionRequestCAS_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateConditionRequestCAS_FieldTerminalPathValue struct {
	UpdateConditionRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateConditionRequestCAS_FieldPathValue = (*UpdateConditionRequestCAS_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CAS' as interface{}
func (fpv *UpdateConditionRequestCAS_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateConditionRequestCAS_FieldTerminalPathValue) AsConditionalStateValue() (*condition.Condition, bool) {
	res, ok := fpv.value.(*condition.Condition)
	return res, ok
}
func (fpv *UpdateConditionRequestCAS_FieldTerminalPathValue) AsFieldMaskValue() (*condition.Condition_FieldMask, bool) {
	res, ok := fpv.value.(*condition.Condition_FieldMask)
	return res, ok
}

// SetTo stores value for selected field for object CAS
func (fpv *UpdateConditionRequestCAS_FieldTerminalPathValue) SetTo(target **UpdateConditionRequest_CAS) {
	if *target == nil {
		*target = new(UpdateConditionRequest_CAS)
	}
	switch fpv.selector {
	case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
		(*target).ConditionalState = fpv.value.(*condition.Condition)
	case UpdateConditionRequestCAS_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*condition.Condition_FieldMask)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest_CAS: %d", fpv.selector))
	}
}

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

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

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

type UpdateConditionRequestCAS_FieldSubPathValue struct {
	UpdateConditionRequestCAS_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateConditionRequestCAS_FieldPathValue = (*UpdateConditionRequestCAS_FieldSubPathValue)(nil)

func (fpvs *UpdateConditionRequestCAS_FieldSubPathValue) AsConditionalStatePathValue() (condition.Condition_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(condition.Condition_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateConditionRequestCAS_FieldSubPathValue) SetTo(target **UpdateConditionRequest_CAS) {
	if *target == nil {
		*target = new(UpdateConditionRequest_CAS)
	}
	switch fpvs.Selector() {
	case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
		fpvs.subPathValue.(condition.Condition_FieldPathValue).SetTo(&(*target).ConditionalState)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateConditionRequestCAS_FieldSubPathValue) CompareWith(source *UpdateConditionRequest_CAS) (int, bool) {
	switch fpvs.Selector() {
	case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
		return fpvs.subPathValue.(condition.Condition_FieldPathValue).CompareWith(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConditionRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

// ParseUpdateConditionRequestCAS_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseUpdateConditionRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) (UpdateConditionRequestCAS_FieldPathArrayItemValue, error) {
	fp, err := ParseUpdateConditionRequestCAS_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.(UpdateConditionRequestCAS_FieldPathArrayItemValue), nil
}

func MustParseUpdateConditionRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) UpdateConditionRequestCAS_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateConditionRequestCAS_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateConditionRequestCAS_FieldTerminalPathArrayItemValue struct {
	UpdateConditionRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateConditionRequestCAS_FieldPathArrayItemValue = (*UpdateConditionRequestCAS_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateConditionRequestCAS_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateConditionRequest_CAS) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'CAS'
func (fpaiv *UpdateConditionRequestCAS_FieldTerminalPathArrayItemValue) ContainsValue(source *UpdateConditionRequest_CAS) bool {
	slice := fpaiv.UpdateConditionRequestCAS_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type UpdateConditionRequestCAS_FieldSubPathArrayItemValue struct {
	UpdateConditionRequestCAS_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

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

func ParseUpdateConditionRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) (UpdateConditionRequestCAS_FieldPathArrayOfValues, error) {
	fp, err := ParseUpdateConditionRequestCAS_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.(UpdateConditionRequestCAS_FieldPathArrayOfValues), nil
}

func MustParseUpdateConditionRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateConditionRequestCAS_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateConditionRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateConditionRequestCAS_FieldTerminalPathArrayOfValues struct {
	UpdateConditionRequestCAS_FieldTerminalPath
	values interface{}
}

var _ UpdateConditionRequestCAS_FieldPathArrayOfValues = (*UpdateConditionRequestCAS_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateConditionRequestCAS_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateConditionRequestCAS_FieldPathSelectorConditionalState:
		for _, v := range fpaov.values.([]*condition.Condition) {
			values = append(values, v)
		}
	case UpdateConditionRequestCAS_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*condition.Condition_FieldMask) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateConditionRequestCAS_FieldTerminalPathArrayOfValues) AsConditionalStateArrayOfValues() ([]*condition.Condition, bool) {
	res, ok := fpaov.values.([]*condition.Condition)
	return res, ok
}
func (fpaov *UpdateConditionRequestCAS_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*condition.Condition_FieldMask, bool) {
	res, ok := fpaov.values.([]*condition.Condition_FieldMask)
	return res, ok
}

type UpdateConditionRequestCAS_FieldSubPathArrayOfValues struct {
	UpdateConditionRequestCAS_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateConditionRequestCAS_FieldPathArrayOfValues = (*UpdateConditionRequestCAS_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateConditionRequestCAS_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateConditionRequestCAS_FieldSubPathArrayOfValues) AsConditionalStatePathArrayOfValues() (condition.Condition_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(condition.Condition_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeleteConditionRequest_FieldPathSelector int32

const (
	DeleteConditionRequest_FieldPathSelectorName DeleteConditionRequest_FieldPathSelector = 0
)

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

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

func ParseDeleteConditionRequest_FieldPath(rawField string) (DeleteConditionRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeleteConditionRequest_FieldPath(fp)
}

func MustParseDeleteConditionRequest_FieldPath(rawField string) DeleteConditionRequest_FieldPath {
	fp, err := ParseDeleteConditionRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeleteConditionRequest_FieldTerminalPath struct {
	selector DeleteConditionRequest_FieldPathSelector
}

var _ DeleteConditionRequest_FieldPath = (*DeleteConditionRequest_FieldTerminalPath)(nil)

func (fp *DeleteConditionRequest_FieldTerminalPath) Selector() DeleteConditionRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *DeleteConditionRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*DeleteConditionRequest))
}

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

func (fp *DeleteConditionRequest_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *DeleteConditionRequest_FieldTerminalPath) WithIValue(value interface{}) DeleteConditionRequest_FieldPathValue {
	switch fp.selector {
	case DeleteConditionRequest_FieldPathSelectorName:
		return &DeleteConditionRequest_FieldTerminalPathValue{DeleteConditionRequest_FieldTerminalPath: *fp, value: value.(*condition.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteConditionRequest: %d", fp.selector))
	}
}

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

func (fp *DeleteConditionRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeleteConditionRequest_FieldPathArrayOfValues {
	fpaov := &DeleteConditionRequest_FieldTerminalPathArrayOfValues{DeleteConditionRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeleteConditionRequest_FieldPathSelectorName:
		return &DeleteConditionRequest_FieldTerminalPathArrayOfValues{DeleteConditionRequest_FieldTerminalPath: *fp, values: values.([]*condition.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteConditionRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParseDeleteConditionRequest_FieldPathValue(pathStr, valueStr string) (DeleteConditionRequest_FieldPathValue, error) {
	fp, err := ParseDeleteConditionRequest_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 DeleteConditionRequest field path value from %s: %v", valueStr, err)
	}
	return fpv.(DeleteConditionRequest_FieldPathValue), nil
}

func MustParseDeleteConditionRequest_FieldPathValue(pathStr, valueStr string) DeleteConditionRequest_FieldPathValue {
	fpv, err := ParseDeleteConditionRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeleteConditionRequest_FieldTerminalPathValue struct {
	DeleteConditionRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteConditionRequest_FieldPathValue = (*DeleteConditionRequest_FieldTerminalPathValue)(nil)

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

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

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

// CompareWith compares value in the 'DeleteConditionRequest_FieldTerminalPathValue' with the value under path in 'DeleteConditionRequest'.
func (fpv *DeleteConditionRequest_FieldTerminalPathValue) CompareWith(source *DeleteConditionRequest) (int, bool) {
	switch fpv.selector {
	case DeleteConditionRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*condition.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 DeleteConditionRequest: %d", fpv.selector))
	}
}

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

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

// ParseDeleteConditionRequest_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseDeleteConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) (DeleteConditionRequest_FieldPathArrayItemValue, error) {
	fp, err := ParseDeleteConditionRequest_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 DeleteConditionRequest field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(DeleteConditionRequest_FieldPathArrayItemValue), nil
}

func MustParseDeleteConditionRequest_FieldPathArrayItemValue(pathStr, valueStr string) DeleteConditionRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseDeleteConditionRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeleteConditionRequest_FieldTerminalPathArrayItemValue struct {
	DeleteConditionRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteConditionRequest_FieldPathArrayItemValue = (*DeleteConditionRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeleteConditionRequest_FieldTerminalPathArrayItemValue) GetSingle(source *DeleteConditionRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'DeleteConditionRequest'
func (fpaiv *DeleteConditionRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *DeleteConditionRequest) bool {
	slice := fpaiv.DeleteConditionRequest_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// DeleteConditionRequest_FieldPathArrayOfValues allows storing slice of values for DeleteConditionRequest fields according to their type
type DeleteConditionRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeleteConditionRequest_FieldPath
}

func ParseDeleteConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) (DeleteConditionRequest_FieldPathArrayOfValues, error) {
	fp, err := ParseDeleteConditionRequest_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 DeleteConditionRequest field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(DeleteConditionRequest_FieldPathArrayOfValues), nil
}

func MustParseDeleteConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr string) DeleteConditionRequest_FieldPathArrayOfValues {
	fpaov, err := ParseDeleteConditionRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeleteConditionRequest_FieldTerminalPathArrayOfValues struct {
	DeleteConditionRequest_FieldTerminalPath
	values interface{}
}

var _ DeleteConditionRequest_FieldPathArrayOfValues = (*DeleteConditionRequest_FieldTerminalPathArrayOfValues)(nil)

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