config_map_service.pb.fieldpath.go

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

package config_map_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 (
	config_map "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha2/config_map"
	project "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha2/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 (
	_ = &config_map.ConfigMap{}
	_ = &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 GetConfigMapRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() GetConfigMapRequest_FieldPathSelector
	Get(source *GetConfigMapRequest) []interface{}
	GetSingle(source *GetConfigMapRequest) (interface{}, bool)
	ClearValue(item *GetConfigMapRequest)

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

type GetConfigMapRequest_FieldPathSelector int32

const (
	GetConfigMapRequest_FieldPathSelectorName      GetConfigMapRequest_FieldPathSelector = 0
	GetConfigMapRequest_FieldPathSelectorFieldMask GetConfigMapRequest_FieldPathSelector = 1
	GetConfigMapRequest_FieldPathSelectorView      GetConfigMapRequest_FieldPathSelector = 2
)

func (s GetConfigMapRequest_FieldPathSelector) String() string {
	switch s {
	case GetConfigMapRequest_FieldPathSelectorName:
		return "name"
	case GetConfigMapRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case GetConfigMapRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for GetConfigMapRequest: %d", s))
	}
}

func BuildGetConfigMapRequest_FieldPath(fp gotenobject.RawFieldPath) (GetConfigMapRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object GetConfigMapRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &GetConfigMapRequest_FieldTerminalPath{selector: GetConfigMapRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &GetConfigMapRequest_FieldTerminalPath{selector: GetConfigMapRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &GetConfigMapRequest_FieldTerminalPath{selector: GetConfigMapRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object GetConfigMapRequest", fp)
}

func ParseGetConfigMapRequest_FieldPath(rawField string) (GetConfigMapRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildGetConfigMapRequest_FieldPath(fp)
}

func MustParseGetConfigMapRequest_FieldPath(rawField string) GetConfigMapRequest_FieldPath {
	fp, err := ParseGetConfigMapRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type GetConfigMapRequest_FieldTerminalPath struct {
	selector GetConfigMapRequest_FieldPathSelector
}

var _ GetConfigMapRequest_FieldPath = (*GetConfigMapRequest_FieldTerminalPath)(nil)

func (fp *GetConfigMapRequest_FieldTerminalPath) Selector() GetConfigMapRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *GetConfigMapRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case GetConfigMapRequest_FieldPathSelectorName:
		return (*config_map.Reference)(nil)
	case GetConfigMapRequest_FieldPathSelectorFieldMask:
		return (*config_map.ConfigMap_FieldMask)(nil)
	case GetConfigMapRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for GetConfigMapRequest: %d", fp.selector))
	}
}

func (fp *GetConfigMapRequest_FieldTerminalPath) ClearValue(item *GetConfigMapRequest) {
	if item != nil {
		switch fp.selector {
		case GetConfigMapRequest_FieldPathSelectorName:
			item.Name = nil
		case GetConfigMapRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case GetConfigMapRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for GetConfigMapRequest: %d", fp.selector))
		}
	}
}

func (fp *GetConfigMapRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*GetConfigMapRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *GetConfigMapRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == GetConfigMapRequest_FieldPathSelectorName ||
		fp.selector == GetConfigMapRequest_FieldPathSelectorFieldMask ||
		fp.selector == GetConfigMapRequest_FieldPathSelectorView
}

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

func (fp *GetConfigMapRequest_FieldTerminalPath) WithIValue(value interface{}) GetConfigMapRequest_FieldPathValue {
	switch fp.selector {
	case GetConfigMapRequest_FieldPathSelectorName:
		return &GetConfigMapRequest_FieldTerminalPathValue{GetConfigMapRequest_FieldTerminalPath: *fp, value: value.(*config_map.Reference)}
	case GetConfigMapRequest_FieldPathSelectorFieldMask:
		return &GetConfigMapRequest_FieldTerminalPathValue{GetConfigMapRequest_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap_FieldMask)}
	case GetConfigMapRequest_FieldPathSelectorView:
		return &GetConfigMapRequest_FieldTerminalPathValue{GetConfigMapRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetConfigMapRequest: %d", fp.selector))
	}
}

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

func (fp *GetConfigMapRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) GetConfigMapRequest_FieldPathArrayOfValues {
	fpaov := &GetConfigMapRequest_FieldTerminalPathArrayOfValues{GetConfigMapRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case GetConfigMapRequest_FieldPathSelectorName:
		return &GetConfigMapRequest_FieldTerminalPathArrayOfValues{GetConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*config_map.Reference)}
	case GetConfigMapRequest_FieldPathSelectorFieldMask:
		return &GetConfigMapRequest_FieldTerminalPathArrayOfValues{GetConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap_FieldMask)}
	case GetConfigMapRequest_FieldPathSelectorView:
		return &GetConfigMapRequest_FieldTerminalPathArrayOfValues{GetConfigMapRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetConfigMapRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseGetConfigMapRequest_FieldPathValue(pathStr, valueStr string) GetConfigMapRequest_FieldPathValue {
	fpv, err := ParseGetConfigMapRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type GetConfigMapRequest_FieldTerminalPathValue struct {
	GetConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ GetConfigMapRequest_FieldPathValue = (*GetConfigMapRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object GetConfigMapRequest
func (fpv *GetConfigMapRequest_FieldTerminalPathValue) SetTo(target **GetConfigMapRequest) {
	if *target == nil {
		*target = new(GetConfigMapRequest)
	}
	switch fpv.selector {
	case GetConfigMapRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*config_map.Reference)
	case GetConfigMapRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*config_map.ConfigMap_FieldMask)
	case GetConfigMapRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for GetConfigMapRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'GetConfigMapRequest_FieldTerminalPathValue' with the value under path in 'GetConfigMapRequest'.
func (fpv *GetConfigMapRequest_FieldTerminalPathValue) CompareWith(source *GetConfigMapRequest) (int, bool) {
	switch fpv.selector {
	case GetConfigMapRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*config_map.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 GetConfigMapRequest_FieldPathSelectorFieldMask:
		return 0, false
	case GetConfigMapRequest_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 GetConfigMapRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseGetConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr string) GetConfigMapRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseGetConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type GetConfigMapRequest_FieldTerminalPathArrayItemValue struct {
	GetConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ GetConfigMapRequest_FieldPathArrayItemValue = (*GetConfigMapRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *GetConfigMapRequest_FieldTerminalPathArrayItemValue) GetSingle(source *GetConfigMapRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'GetConfigMapRequest'
func (fpaiv *GetConfigMapRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *GetConfigMapRequest) bool {
	slice := fpaiv.GetConfigMapRequest_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
}

// GetConfigMapRequest_FieldPathArrayOfValues allows storing slice of values for GetConfigMapRequest fields according to their type
type GetConfigMapRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	GetConfigMapRequest_FieldPath
}

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

func MustParseGetConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr string) GetConfigMapRequest_FieldPathArrayOfValues {
	fpaov, err := ParseGetConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type GetConfigMapRequest_FieldTerminalPathArrayOfValues struct {
	GetConfigMapRequest_FieldTerminalPath
	values interface{}
}

var _ GetConfigMapRequest_FieldPathArrayOfValues = (*GetConfigMapRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *GetConfigMapRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case GetConfigMapRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*config_map.Reference) {
			values = append(values, v)
		}
	case GetConfigMapRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*config_map.ConfigMap_FieldMask) {
			values = append(values, v)
		}
	case GetConfigMapRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *GetConfigMapRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*config_map.Reference, bool) {
	res, ok := fpaov.values.([]*config_map.Reference)
	return res, ok
}
func (fpaov *GetConfigMapRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*config_map.ConfigMap_FieldMask, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap_FieldMask)
	return res, ok
}
func (fpaov *GetConfigMapRequest_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 BatchGetConfigMapsRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetConfigMapsRequest_FieldPathSelector
	Get(source *BatchGetConfigMapsRequest) []interface{}
	GetSingle(source *BatchGetConfigMapsRequest) (interface{}, bool)
	ClearValue(item *BatchGetConfigMapsRequest)

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

type BatchGetConfigMapsRequest_FieldPathSelector int32

const (
	BatchGetConfigMapsRequest_FieldPathSelectorNames     BatchGetConfigMapsRequest_FieldPathSelector = 0
	BatchGetConfigMapsRequest_FieldPathSelectorFieldMask BatchGetConfigMapsRequest_FieldPathSelector = 1
	BatchGetConfigMapsRequest_FieldPathSelectorView      BatchGetConfigMapsRequest_FieldPathSelector = 2
)

func (s BatchGetConfigMapsRequest_FieldPathSelector) String() string {
	switch s {
	case BatchGetConfigMapsRequest_FieldPathSelectorNames:
		return "names"
	case BatchGetConfigMapsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case BatchGetConfigMapsRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsRequest: %d", s))
	}
}

func BuildBatchGetConfigMapsRequest_FieldPath(fp gotenobject.RawFieldPath) (BatchGetConfigMapsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetConfigMapsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "names":
			return &BatchGetConfigMapsRequest_FieldTerminalPath{selector: BatchGetConfigMapsRequest_FieldPathSelectorNames}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &BatchGetConfigMapsRequest_FieldTerminalPath{selector: BatchGetConfigMapsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &BatchGetConfigMapsRequest_FieldTerminalPath{selector: BatchGetConfigMapsRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetConfigMapsRequest", fp)
}

func ParseBatchGetConfigMapsRequest_FieldPath(rawField string) (BatchGetConfigMapsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetConfigMapsRequest_FieldPath(fp)
}

func MustParseBatchGetConfigMapsRequest_FieldPath(rawField string) BatchGetConfigMapsRequest_FieldPath {
	fp, err := ParseBatchGetConfigMapsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetConfigMapsRequest_FieldTerminalPath struct {
	selector BatchGetConfigMapsRequest_FieldPathSelector
}

var _ BatchGetConfigMapsRequest_FieldPath = (*BatchGetConfigMapsRequest_FieldTerminalPath)(nil)

func (fp *BatchGetConfigMapsRequest_FieldTerminalPath) Selector() BatchGetConfigMapsRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *BatchGetConfigMapsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetConfigMapsRequest_FieldPathSelectorNames:
		return ([]*config_map.Reference)(nil)
	case BatchGetConfigMapsRequest_FieldPathSelectorFieldMask:
		return (*config_map.ConfigMap_FieldMask)(nil)
	case BatchGetConfigMapsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsRequest: %d", fp.selector))
	}
}

func (fp *BatchGetConfigMapsRequest_FieldTerminalPath) ClearValue(item *BatchGetConfigMapsRequest) {
	if item != nil {
		switch fp.selector {
		case BatchGetConfigMapsRequest_FieldPathSelectorNames:
			item.Names = nil
		case BatchGetConfigMapsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case BatchGetConfigMapsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsRequest: %d", fp.selector))
		}
	}
}

func (fp *BatchGetConfigMapsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetConfigMapsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *BatchGetConfigMapsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == BatchGetConfigMapsRequest_FieldPathSelectorNames ||
		fp.selector == BatchGetConfigMapsRequest_FieldPathSelectorFieldMask ||
		fp.selector == BatchGetConfigMapsRequest_FieldPathSelectorView
}

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

func (fp *BatchGetConfigMapsRequest_FieldTerminalPath) WithIValue(value interface{}) BatchGetConfigMapsRequest_FieldPathValue {
	switch fp.selector {
	case BatchGetConfigMapsRequest_FieldPathSelectorNames:
		return &BatchGetConfigMapsRequest_FieldTerminalPathValue{BatchGetConfigMapsRequest_FieldTerminalPath: *fp, value: value.([]*config_map.Reference)}
	case BatchGetConfigMapsRequest_FieldPathSelectorFieldMask:
		return &BatchGetConfigMapsRequest_FieldTerminalPathValue{BatchGetConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap_FieldMask)}
	case BatchGetConfigMapsRequest_FieldPathSelectorView:
		return &BatchGetConfigMapsRequest_FieldTerminalPathValue{BatchGetConfigMapsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsRequest: %d", fp.selector))
	}
}

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

func (fp *BatchGetConfigMapsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetConfigMapsRequest_FieldPathArrayOfValues {
	fpaov := &BatchGetConfigMapsRequest_FieldTerminalPathArrayOfValues{BatchGetConfigMapsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetConfigMapsRequest_FieldPathSelectorNames:
		return &BatchGetConfigMapsRequest_FieldTerminalPathArrayOfValues{BatchGetConfigMapsRequest_FieldTerminalPath: *fp, values: values.([][]*config_map.Reference)}
	case BatchGetConfigMapsRequest_FieldPathSelectorFieldMask:
		return &BatchGetConfigMapsRequest_FieldTerminalPathArrayOfValues{BatchGetConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap_FieldMask)}
	case BatchGetConfigMapsRequest_FieldPathSelectorView:
		return &BatchGetConfigMapsRequest_FieldTerminalPathArrayOfValues{BatchGetConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsRequest: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetConfigMapsRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetConfigMapsRequest_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetConfigMapsRequest_FieldPathSelectorNames:
		return &BatchGetConfigMapsRequest_FieldTerminalPathArrayItemValue{BatchGetConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsRequest: %d", fp.selector))
	}
}

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

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

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

func MustParseBatchGetConfigMapsRequest_FieldPathValue(pathStr, valueStr string) BatchGetConfigMapsRequest_FieldPathValue {
	fpv, err := ParseBatchGetConfigMapsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetConfigMapsRequest_FieldTerminalPathValue struct {
	BatchGetConfigMapsRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetConfigMapsRequest_FieldPathValue = (*BatchGetConfigMapsRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object BatchGetConfigMapsRequest
func (fpv *BatchGetConfigMapsRequest_FieldTerminalPathValue) SetTo(target **BatchGetConfigMapsRequest) {
	if *target == nil {
		*target = new(BatchGetConfigMapsRequest)
	}
	switch fpv.selector {
	case BatchGetConfigMapsRequest_FieldPathSelectorNames:
		(*target).Names = fpv.value.([]*config_map.Reference)
	case BatchGetConfigMapsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*config_map.ConfigMap_FieldMask)
	case BatchGetConfigMapsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsRequest: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseBatchGetConfigMapsRequest_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetConfigMapsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetConfigMapsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetConfigMapsRequest_FieldTerminalPathArrayItemValue struct {
	BatchGetConfigMapsRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetConfigMapsRequest_FieldPathArrayItemValue = (*BatchGetConfigMapsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *BatchGetConfigMapsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetConfigMapsRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'BatchGetConfigMapsRequest'
func (fpaiv *BatchGetConfigMapsRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *BatchGetConfigMapsRequest) bool {
	slice := fpaiv.BatchGetConfigMapsRequest_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
}

// BatchGetConfigMapsRequest_FieldPathArrayOfValues allows storing slice of values for BatchGetConfigMapsRequest fields according to their type
type BatchGetConfigMapsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetConfigMapsRequest_FieldPath
}

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

func MustParseBatchGetConfigMapsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetConfigMapsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetConfigMapsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetConfigMapsRequest_FieldTerminalPathArrayOfValues struct {
	BatchGetConfigMapsRequest_FieldTerminalPath
	values interface{}
}

var _ BatchGetConfigMapsRequest_FieldPathArrayOfValues = (*BatchGetConfigMapsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetConfigMapsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetConfigMapsRequest_FieldPathSelectorNames:
		for _, v := range fpaov.values.([][]*config_map.Reference) {
			values = append(values, v)
		}
	case BatchGetConfigMapsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*config_map.ConfigMap_FieldMask) {
			values = append(values, v)
		}
	case BatchGetConfigMapsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetConfigMapsRequest_FieldTerminalPathArrayOfValues) AsNamesArrayOfValues() ([][]*config_map.Reference, bool) {
	res, ok := fpaov.values.([][]*config_map.Reference)
	return res, ok
}
func (fpaov *BatchGetConfigMapsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*config_map.ConfigMap_FieldMask, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap_FieldMask)
	return res, ok
}
func (fpaov *BatchGetConfigMapsRequest_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 BatchGetConfigMapsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetConfigMapsResponse_FieldPathSelector
	Get(source *BatchGetConfigMapsResponse) []interface{}
	GetSingle(source *BatchGetConfigMapsResponse) (interface{}, bool)
	ClearValue(item *BatchGetConfigMapsResponse)

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

type BatchGetConfigMapsResponse_FieldPathSelector int32

const (
	BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps BatchGetConfigMapsResponse_FieldPathSelector = 0
	BatchGetConfigMapsResponse_FieldPathSelectorMissing    BatchGetConfigMapsResponse_FieldPathSelector = 1
)

func (s BatchGetConfigMapsResponse_FieldPathSelector) String() string {
	switch s {
	case BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps:
		return "config_maps"
	case BatchGetConfigMapsResponse_FieldPathSelectorMissing:
		return "missing"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsResponse: %d", s))
	}
}

func BuildBatchGetConfigMapsResponse_FieldPath(fp gotenobject.RawFieldPath) (BatchGetConfigMapsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetConfigMapsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "config_maps", "configMaps", "config-maps":
			return &BatchGetConfigMapsResponse_FieldTerminalPath{selector: BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps}, nil
		case "missing":
			return &BatchGetConfigMapsResponse_FieldTerminalPath{selector: BatchGetConfigMapsResponse_FieldPathSelectorMissing}, nil
		}
	} else {
		switch fp[0] {
		case "config_maps", "configMaps", "config-maps":
			if subpath, err := config_map.BuildConfigMap_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &BatchGetConfigMapsResponse_FieldSubPath{selector: BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetConfigMapsResponse", fp)
}

func ParseBatchGetConfigMapsResponse_FieldPath(rawField string) (BatchGetConfigMapsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetConfigMapsResponse_FieldPath(fp)
}

func MustParseBatchGetConfigMapsResponse_FieldPath(rawField string) BatchGetConfigMapsResponse_FieldPath {
	fp, err := ParseBatchGetConfigMapsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetConfigMapsResponse_FieldTerminalPath struct {
	selector BatchGetConfigMapsResponse_FieldPathSelector
}

var _ BatchGetConfigMapsResponse_FieldPath = (*BatchGetConfigMapsResponse_FieldTerminalPath)(nil)

func (fp *BatchGetConfigMapsResponse_FieldTerminalPath) Selector() BatchGetConfigMapsResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *BatchGetConfigMapsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps:
		return ([]*config_map.ConfigMap)(nil)
	case BatchGetConfigMapsResponse_FieldPathSelectorMissing:
		return ([]*config_map.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsResponse: %d", fp.selector))
	}
}

func (fp *BatchGetConfigMapsResponse_FieldTerminalPath) ClearValue(item *BatchGetConfigMapsResponse) {
	if item != nil {
		switch fp.selector {
		case BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps:
			item.ConfigMaps = nil
		case BatchGetConfigMapsResponse_FieldPathSelectorMissing:
			item.Missing = nil
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsResponse: %d", fp.selector))
		}
	}
}

func (fp *BatchGetConfigMapsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetConfigMapsResponse))
}

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

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

func (fp *BatchGetConfigMapsResponse_FieldTerminalPath) WithIValue(value interface{}) BatchGetConfigMapsResponse_FieldPathValue {
	switch fp.selector {
	case BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps:
		return &BatchGetConfigMapsResponse_FieldTerminalPathValue{BatchGetConfigMapsResponse_FieldTerminalPath: *fp, value: value.([]*config_map.ConfigMap)}
	case BatchGetConfigMapsResponse_FieldPathSelectorMissing:
		return &BatchGetConfigMapsResponse_FieldTerminalPathValue{BatchGetConfigMapsResponse_FieldTerminalPath: *fp, value: value.([]*config_map.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsResponse: %d", fp.selector))
	}
}

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

func (fp *BatchGetConfigMapsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetConfigMapsResponse_FieldPathArrayOfValues {
	fpaov := &BatchGetConfigMapsResponse_FieldTerminalPathArrayOfValues{BatchGetConfigMapsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps:
		return &BatchGetConfigMapsResponse_FieldTerminalPathArrayOfValues{BatchGetConfigMapsResponse_FieldTerminalPath: *fp, values: values.([][]*config_map.ConfigMap)}
	case BatchGetConfigMapsResponse_FieldPathSelectorMissing:
		return &BatchGetConfigMapsResponse_FieldTerminalPathArrayOfValues{BatchGetConfigMapsResponse_FieldTerminalPath: *fp, values: values.([][]*config_map.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetConfigMapsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetConfigMapsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps:
		return &BatchGetConfigMapsResponse_FieldTerminalPathArrayItemValue{BatchGetConfigMapsResponse_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap)}
	case BatchGetConfigMapsResponse_FieldPathSelectorMissing:
		return &BatchGetConfigMapsResponse_FieldTerminalPathArrayItemValue{BatchGetConfigMapsResponse_FieldTerminalPath: *fp, value: value.(*config_map.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsResponse: %d", fp.selector))
	}
}

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

type BatchGetConfigMapsResponse_FieldSubPath struct {
	selector BatchGetConfigMapsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ BatchGetConfigMapsResponse_FieldPath = (*BatchGetConfigMapsResponse_FieldSubPath)(nil)

func (fps *BatchGetConfigMapsResponse_FieldSubPath) Selector() BatchGetConfigMapsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *BatchGetConfigMapsResponse_FieldSubPath) AsConfigMapsSubPath() (config_map.ConfigMap_FieldPath, bool) {
	res, ok := fps.subPath.(config_map.ConfigMap_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *BatchGetConfigMapsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*BatchGetConfigMapsResponse))
}

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

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

func (fps *BatchGetConfigMapsResponse_FieldSubPath) WithIValue(value interface{}) BatchGetConfigMapsResponse_FieldPathValue {
	return &BatchGetConfigMapsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *BatchGetConfigMapsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) BatchGetConfigMapsResponse_FieldPathArrayOfValues {
	return &BatchGetConfigMapsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *BatchGetConfigMapsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) BatchGetConfigMapsResponse_FieldPathArrayItemValue {
	return &BatchGetConfigMapsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseBatchGetConfigMapsResponse_FieldPathValue(pathStr, valueStr string) BatchGetConfigMapsResponse_FieldPathValue {
	fpv, err := ParseBatchGetConfigMapsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetConfigMapsResponse_FieldTerminalPathValue struct {
	BatchGetConfigMapsResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetConfigMapsResponse_FieldPathValue = (*BatchGetConfigMapsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetConfigMapsResponse' as interface{}
func (fpv *BatchGetConfigMapsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetConfigMapsResponse_FieldTerminalPathValue) AsConfigMapsValue() ([]*config_map.ConfigMap, bool) {
	res, ok := fpv.value.([]*config_map.ConfigMap)
	return res, ok
}
func (fpv *BatchGetConfigMapsResponse_FieldTerminalPathValue) AsMissingValue() ([]*config_map.Reference, bool) {
	res, ok := fpv.value.([]*config_map.Reference)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetConfigMapsResponse
func (fpv *BatchGetConfigMapsResponse_FieldTerminalPathValue) SetTo(target **BatchGetConfigMapsResponse) {
	if *target == nil {
		*target = new(BatchGetConfigMapsResponse)
	}
	switch fpv.selector {
	case BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps:
		(*target).ConfigMaps = fpv.value.([]*config_map.ConfigMap)
	case BatchGetConfigMapsResponse_FieldPathSelectorMissing:
		(*target).Missing = fpv.value.([]*config_map.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetConfigMapsResponse: %d", fpv.selector))
	}
}

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

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

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

type BatchGetConfigMapsResponse_FieldSubPathValue struct {
	BatchGetConfigMapsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ BatchGetConfigMapsResponse_FieldPathValue = (*BatchGetConfigMapsResponse_FieldSubPathValue)(nil)

func (fpvs *BatchGetConfigMapsResponse_FieldSubPathValue) AsConfigMapsPathValue() (config_map.ConfigMap_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseBatchGetConfigMapsResponse_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetConfigMapsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetConfigMapsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetConfigMapsResponse_FieldTerminalPathArrayItemValue struct {
	BatchGetConfigMapsResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetConfigMapsResponse_FieldPathArrayItemValue = (*BatchGetConfigMapsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetConfigMapsResponse as interface{}
func (fpaiv *BatchGetConfigMapsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetConfigMapsResponse_FieldTerminalPathArrayItemValue) AsConfigMapsItemValue() (*config_map.ConfigMap, bool) {
	res, ok := fpaiv.value.(*config_map.ConfigMap)
	return res, ok
}
func (fpaiv *BatchGetConfigMapsResponse_FieldTerminalPathArrayItemValue) AsMissingItemValue() (*config_map.Reference, bool) {
	res, ok := fpaiv.value.(*config_map.Reference)
	return res, ok
}

func (fpaiv *BatchGetConfigMapsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetConfigMapsResponse) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'BatchGetConfigMapsResponse'
func (fpaiv *BatchGetConfigMapsResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *BatchGetConfigMapsResponse) bool {
	slice := fpaiv.BatchGetConfigMapsResponse_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 BatchGetConfigMapsResponse_FieldSubPathArrayItemValue struct {
	BatchGetConfigMapsResponse_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *BatchGetConfigMapsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *BatchGetConfigMapsResponse_FieldSubPathArrayItemValue) AsConfigMapsPathItemValue() (config_map.ConfigMap_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(config_map.ConfigMap_FieldPathArrayItemValue)
	return res, ok
}

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

// BatchGetConfigMapsResponse_FieldPathArrayOfValues allows storing slice of values for BatchGetConfigMapsResponse fields according to their type
type BatchGetConfigMapsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetConfigMapsResponse_FieldPath
}

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

func MustParseBatchGetConfigMapsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetConfigMapsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetConfigMapsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetConfigMapsResponse_FieldTerminalPathArrayOfValues struct {
	BatchGetConfigMapsResponse_FieldTerminalPath
	values interface{}
}

var _ BatchGetConfigMapsResponse_FieldPathArrayOfValues = (*BatchGetConfigMapsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetConfigMapsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetConfigMapsResponse_FieldPathSelectorConfigMaps:
		for _, v := range fpaov.values.([][]*config_map.ConfigMap) {
			values = append(values, v)
		}
	case BatchGetConfigMapsResponse_FieldPathSelectorMissing:
		for _, v := range fpaov.values.([][]*config_map.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetConfigMapsResponse_FieldTerminalPathArrayOfValues) AsConfigMapsArrayOfValues() ([][]*config_map.ConfigMap, bool) {
	res, ok := fpaov.values.([][]*config_map.ConfigMap)
	return res, ok
}
func (fpaov *BatchGetConfigMapsResponse_FieldTerminalPathArrayOfValues) AsMissingArrayOfValues() ([][]*config_map.Reference, bool) {
	res, ok := fpaov.values.([][]*config_map.Reference)
	return res, ok
}

type BatchGetConfigMapsResponse_FieldSubPathArrayOfValues struct {
	BatchGetConfigMapsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ BatchGetConfigMapsResponse_FieldPathArrayOfValues = (*BatchGetConfigMapsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *BatchGetConfigMapsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *BatchGetConfigMapsResponse_FieldSubPathArrayOfValues) AsConfigMapsPathArrayOfValues() (config_map.ConfigMap_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(config_map.ConfigMap_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ListConfigMapsRequest_FieldPathSelector int32

const (
	ListConfigMapsRequest_FieldPathSelectorParent            ListConfigMapsRequest_FieldPathSelector = 0
	ListConfigMapsRequest_FieldPathSelectorPageSize          ListConfigMapsRequest_FieldPathSelector = 1
	ListConfigMapsRequest_FieldPathSelectorPageToken         ListConfigMapsRequest_FieldPathSelector = 2
	ListConfigMapsRequest_FieldPathSelectorOrderBy           ListConfigMapsRequest_FieldPathSelector = 3
	ListConfigMapsRequest_FieldPathSelectorFilter            ListConfigMapsRequest_FieldPathSelector = 4
	ListConfigMapsRequest_FieldPathSelectorFieldMask         ListConfigMapsRequest_FieldPathSelector = 5
	ListConfigMapsRequest_FieldPathSelectorView              ListConfigMapsRequest_FieldPathSelector = 6
	ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo ListConfigMapsRequest_FieldPathSelector = 7
)

func (s ListConfigMapsRequest_FieldPathSelector) String() string {
	switch s {
	case ListConfigMapsRequest_FieldPathSelectorParent:
		return "parent"
	case ListConfigMapsRequest_FieldPathSelectorPageSize:
		return "page_size"
	case ListConfigMapsRequest_FieldPathSelectorPageToken:
		return "page_token"
	case ListConfigMapsRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case ListConfigMapsRequest_FieldPathSelectorFilter:
		return "filter"
	case ListConfigMapsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case ListConfigMapsRequest_FieldPathSelectorView:
		return "view"
	case ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo:
		return "include_paging_info"
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsRequest: %d", s))
	}
}

func BuildListConfigMapsRequest_FieldPath(fp gotenobject.RawFieldPath) (ListConfigMapsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListConfigMapsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &ListConfigMapsRequest_FieldTerminalPath{selector: ListConfigMapsRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &ListConfigMapsRequest_FieldTerminalPath{selector: ListConfigMapsRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &ListConfigMapsRequest_FieldTerminalPath{selector: ListConfigMapsRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &ListConfigMapsRequest_FieldTerminalPath{selector: ListConfigMapsRequest_FieldPathSelectorOrderBy}, nil
		case "filter":
			return &ListConfigMapsRequest_FieldTerminalPath{selector: ListConfigMapsRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &ListConfigMapsRequest_FieldTerminalPath{selector: ListConfigMapsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &ListConfigMapsRequest_FieldTerminalPath{selector: ListConfigMapsRequest_FieldPathSelectorView}, nil
		case "include_paging_info", "includePagingInfo", "include-paging-info":
			return &ListConfigMapsRequest_FieldTerminalPath{selector: ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListConfigMapsRequest", fp)
}

func ParseListConfigMapsRequest_FieldPath(rawField string) (ListConfigMapsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListConfigMapsRequest_FieldPath(fp)
}

func MustParseListConfigMapsRequest_FieldPath(rawField string) ListConfigMapsRequest_FieldPath {
	fp, err := ParseListConfigMapsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListConfigMapsRequest_FieldTerminalPath struct {
	selector ListConfigMapsRequest_FieldPathSelector
}

var _ ListConfigMapsRequest_FieldPath = (*ListConfigMapsRequest_FieldTerminalPath)(nil)

func (fp *ListConfigMapsRequest_FieldTerminalPath) Selector() ListConfigMapsRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListConfigMapsRequest
func (fp *ListConfigMapsRequest_FieldTerminalPath) Get(source *ListConfigMapsRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListConfigMapsRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case ListConfigMapsRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case ListConfigMapsRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case ListConfigMapsRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case ListConfigMapsRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case ListConfigMapsRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case ListConfigMapsRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo:
			values = append(values, source.IncludePagingInfo)
		default:
			panic(fmt.Sprintf("Invalid selector for ListConfigMapsRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListConfigMapsRequest
func (fp *ListConfigMapsRequest_FieldTerminalPath) GetSingle(source *ListConfigMapsRequest) (interface{}, bool) {
	switch fp.selector {
	case ListConfigMapsRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case ListConfigMapsRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case ListConfigMapsRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case ListConfigMapsRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case ListConfigMapsRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case ListConfigMapsRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case ListConfigMapsRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo:
		return source.GetIncludePagingInfo(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListConfigMapsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListConfigMapsRequest_FieldPathSelectorParent:
		return (*config_map.ParentName)(nil)
	case ListConfigMapsRequest_FieldPathSelectorPageSize:
		return int32(0)
	case ListConfigMapsRequest_FieldPathSelectorPageToken:
		return (*config_map.PagerCursor)(nil)
	case ListConfigMapsRequest_FieldPathSelectorOrderBy:
		return (*config_map.OrderBy)(nil)
	case ListConfigMapsRequest_FieldPathSelectorFilter:
		return (*config_map.Filter)(nil)
	case ListConfigMapsRequest_FieldPathSelectorFieldMask:
		return (*config_map.ConfigMap_FieldMask)(nil)
	case ListConfigMapsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsRequest: %d", fp.selector))
	}
}

func (fp *ListConfigMapsRequest_FieldTerminalPath) ClearValue(item *ListConfigMapsRequest) {
	if item != nil {
		switch fp.selector {
		case ListConfigMapsRequest_FieldPathSelectorParent:
			item.Parent = nil
		case ListConfigMapsRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case ListConfigMapsRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case ListConfigMapsRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case ListConfigMapsRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case ListConfigMapsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case ListConfigMapsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo:
			item.IncludePagingInfo = false
		default:
			panic(fmt.Sprintf("Invalid selector for ListConfigMapsRequest: %d", fp.selector))
		}
	}
}

func (fp *ListConfigMapsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListConfigMapsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListConfigMapsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListConfigMapsRequest_FieldPathSelectorParent ||
		fp.selector == ListConfigMapsRequest_FieldPathSelectorPageSize ||
		fp.selector == ListConfigMapsRequest_FieldPathSelectorPageToken ||
		fp.selector == ListConfigMapsRequest_FieldPathSelectorOrderBy ||
		fp.selector == ListConfigMapsRequest_FieldPathSelectorFilter ||
		fp.selector == ListConfigMapsRequest_FieldPathSelectorFieldMask ||
		fp.selector == ListConfigMapsRequest_FieldPathSelectorView ||
		fp.selector == ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo
}

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

func (fp *ListConfigMapsRequest_FieldTerminalPath) WithIValue(value interface{}) ListConfigMapsRequest_FieldPathValue {
	switch fp.selector {
	case ListConfigMapsRequest_FieldPathSelectorParent:
		return &ListConfigMapsRequest_FieldTerminalPathValue{ListConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.ParentName)}
	case ListConfigMapsRequest_FieldPathSelectorPageSize:
		return &ListConfigMapsRequest_FieldTerminalPathValue{ListConfigMapsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case ListConfigMapsRequest_FieldPathSelectorPageToken:
		return &ListConfigMapsRequest_FieldTerminalPathValue{ListConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.PagerCursor)}
	case ListConfigMapsRequest_FieldPathSelectorOrderBy:
		return &ListConfigMapsRequest_FieldTerminalPathValue{ListConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.OrderBy)}
	case ListConfigMapsRequest_FieldPathSelectorFilter:
		return &ListConfigMapsRequest_FieldTerminalPathValue{ListConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.Filter)}
	case ListConfigMapsRequest_FieldPathSelectorFieldMask:
		return &ListConfigMapsRequest_FieldTerminalPathValue{ListConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap_FieldMask)}
	case ListConfigMapsRequest_FieldPathSelectorView:
		return &ListConfigMapsRequest_FieldTerminalPathValue{ListConfigMapsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo:
		return &ListConfigMapsRequest_FieldTerminalPathValue{ListConfigMapsRequest_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsRequest: %d", fp.selector))
	}
}

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

func (fp *ListConfigMapsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListConfigMapsRequest_FieldPathArrayOfValues {
	fpaov := &ListConfigMapsRequest_FieldTerminalPathArrayOfValues{ListConfigMapsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListConfigMapsRequest_FieldPathSelectorParent:
		return &ListConfigMapsRequest_FieldTerminalPathArrayOfValues{ListConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ParentName)}
	case ListConfigMapsRequest_FieldPathSelectorPageSize:
		return &ListConfigMapsRequest_FieldTerminalPathArrayOfValues{ListConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListConfigMapsRequest_FieldPathSelectorPageToken:
		return &ListConfigMapsRequest_FieldTerminalPathArrayOfValues{ListConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.PagerCursor)}
	case ListConfigMapsRequest_FieldPathSelectorOrderBy:
		return &ListConfigMapsRequest_FieldTerminalPathArrayOfValues{ListConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.OrderBy)}
	case ListConfigMapsRequest_FieldPathSelectorFilter:
		return &ListConfigMapsRequest_FieldTerminalPathArrayOfValues{ListConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.Filter)}
	case ListConfigMapsRequest_FieldPathSelectorFieldMask:
		return &ListConfigMapsRequest_FieldTerminalPathArrayOfValues{ListConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap_FieldMask)}
	case ListConfigMapsRequest_FieldPathSelectorView:
		return &ListConfigMapsRequest_FieldTerminalPathArrayOfValues{ListConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo:
		return &ListConfigMapsRequest_FieldTerminalPathArrayOfValues{ListConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseListConfigMapsRequest_FieldPathValue(pathStr, valueStr string) ListConfigMapsRequest_FieldPathValue {
	fpv, err := ParseListConfigMapsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListConfigMapsRequest_FieldTerminalPathValue struct {
	ListConfigMapsRequest_FieldTerminalPath
	value interface{}
}

var _ ListConfigMapsRequest_FieldPathValue = (*ListConfigMapsRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object ListConfigMapsRequest
func (fpv *ListConfigMapsRequest_FieldTerminalPathValue) SetTo(target **ListConfigMapsRequest) {
	if *target == nil {
		*target = new(ListConfigMapsRequest)
	}
	switch fpv.selector {
	case ListConfigMapsRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*config_map.ParentName)
	case ListConfigMapsRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case ListConfigMapsRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*config_map.PagerCursor)
	case ListConfigMapsRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*config_map.OrderBy)
	case ListConfigMapsRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*config_map.Filter)
	case ListConfigMapsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*config_map.ConfigMap_FieldMask)
	case ListConfigMapsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo:
		(*target).IncludePagingInfo = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListConfigMapsRequest_FieldTerminalPathValue' with the value under path in 'ListConfigMapsRequest'.
func (fpv *ListConfigMapsRequest_FieldTerminalPathValue) CompareWith(source *ListConfigMapsRequest) (int, bool) {
	switch fpv.selector {
	case ListConfigMapsRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*config_map.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 ListConfigMapsRequest_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 ListConfigMapsRequest_FieldPathSelectorPageToken:
		return 0, false
	case ListConfigMapsRequest_FieldPathSelectorOrderBy:
		return 0, false
	case ListConfigMapsRequest_FieldPathSelectorFilter:
		return 0, false
	case ListConfigMapsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case ListConfigMapsRequest_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 ListConfigMapsRequest_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 ListConfigMapsRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseListConfigMapsRequest_FieldPathArrayItemValue(pathStr, valueStr string) ListConfigMapsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseListConfigMapsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListConfigMapsRequest_FieldTerminalPathArrayItemValue struct {
	ListConfigMapsRequest_FieldTerminalPath
	value interface{}
}

var _ ListConfigMapsRequest_FieldPathArrayItemValue = (*ListConfigMapsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ListConfigMapsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ListConfigMapsRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ListConfigMapsRequest'
func (fpaiv *ListConfigMapsRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *ListConfigMapsRequest) bool {
	slice := fpaiv.ListConfigMapsRequest_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
}

// ListConfigMapsRequest_FieldPathArrayOfValues allows storing slice of values for ListConfigMapsRequest fields according to their type
type ListConfigMapsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListConfigMapsRequest_FieldPath
}

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

func MustParseListConfigMapsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ListConfigMapsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseListConfigMapsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListConfigMapsRequest_FieldTerminalPathArrayOfValues struct {
	ListConfigMapsRequest_FieldTerminalPath
	values interface{}
}

var _ ListConfigMapsRequest_FieldPathArrayOfValues = (*ListConfigMapsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListConfigMapsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListConfigMapsRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*config_map.ParentName) {
			values = append(values, v)
		}
	case ListConfigMapsRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListConfigMapsRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*config_map.PagerCursor) {
			values = append(values, v)
		}
	case ListConfigMapsRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*config_map.OrderBy) {
			values = append(values, v)
		}
	case ListConfigMapsRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*config_map.Filter) {
			values = append(values, v)
		}
	case ListConfigMapsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*config_map.ConfigMap_FieldMask) {
			values = append(values, v)
		}
	case ListConfigMapsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case ListConfigMapsRequest_FieldPathSelectorIncludePagingInfo:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListConfigMapsRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*config_map.ParentName, bool) {
	res, ok := fpaov.values.([]*config_map.ParentName)
	return res, ok
}
func (fpaov *ListConfigMapsRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListConfigMapsRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*config_map.PagerCursor, bool) {
	res, ok := fpaov.values.([]*config_map.PagerCursor)
	return res, ok
}
func (fpaov *ListConfigMapsRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*config_map.OrderBy, bool) {
	res, ok := fpaov.values.([]*config_map.OrderBy)
	return res, ok
}
func (fpaov *ListConfigMapsRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*config_map.Filter, bool) {
	res, ok := fpaov.values.([]*config_map.Filter)
	return res, ok
}
func (fpaov *ListConfigMapsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*config_map.ConfigMap_FieldMask, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap_FieldMask)
	return res, ok
}
func (fpaov *ListConfigMapsRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *ListConfigMapsRequest_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 ListConfigMapsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() ListConfigMapsResponse_FieldPathSelector
	Get(source *ListConfigMapsResponse) []interface{}
	GetSingle(source *ListConfigMapsResponse) (interface{}, bool)
	ClearValue(item *ListConfigMapsResponse)

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

type ListConfigMapsResponse_FieldPathSelector int32

const (
	ListConfigMapsResponse_FieldPathSelectorConfigMaps        ListConfigMapsResponse_FieldPathSelector = 0
	ListConfigMapsResponse_FieldPathSelectorPrevPageToken     ListConfigMapsResponse_FieldPathSelector = 1
	ListConfigMapsResponse_FieldPathSelectorNextPageToken     ListConfigMapsResponse_FieldPathSelector = 2
	ListConfigMapsResponse_FieldPathSelectorCurrentOffset     ListConfigMapsResponse_FieldPathSelector = 3
	ListConfigMapsResponse_FieldPathSelectorTotalResultsCount ListConfigMapsResponse_FieldPathSelector = 4
)

func (s ListConfigMapsResponse_FieldPathSelector) String() string {
	switch s {
	case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
		return "config_maps"
	case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
		return "next_page_token"
	case ListConfigMapsResponse_FieldPathSelectorCurrentOffset:
		return "current_offset"
	case ListConfigMapsResponse_FieldPathSelectorTotalResultsCount:
		return "total_results_count"
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsResponse: %d", s))
	}
}

func BuildListConfigMapsResponse_FieldPath(fp gotenobject.RawFieldPath) (ListConfigMapsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListConfigMapsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "config_maps", "configMaps", "config-maps":
			return &ListConfigMapsResponse_FieldTerminalPath{selector: ListConfigMapsResponse_FieldPathSelectorConfigMaps}, nil
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &ListConfigMapsResponse_FieldTerminalPath{selector: ListConfigMapsResponse_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &ListConfigMapsResponse_FieldTerminalPath{selector: ListConfigMapsResponse_FieldPathSelectorNextPageToken}, nil
		case "current_offset", "currentOffset", "current-offset":
			return &ListConfigMapsResponse_FieldTerminalPath{selector: ListConfigMapsResponse_FieldPathSelectorCurrentOffset}, nil
		case "total_results_count", "totalResultsCount", "total-results-count":
			return &ListConfigMapsResponse_FieldTerminalPath{selector: ListConfigMapsResponse_FieldPathSelectorTotalResultsCount}, nil
		}
	} else {
		switch fp[0] {
		case "config_maps", "configMaps", "config-maps":
			if subpath, err := config_map.BuildConfigMap_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListConfigMapsResponse_FieldSubPath{selector: ListConfigMapsResponse_FieldPathSelectorConfigMaps, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListConfigMapsResponse", fp)
}

func ParseListConfigMapsResponse_FieldPath(rawField string) (ListConfigMapsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListConfigMapsResponse_FieldPath(fp)
}

func MustParseListConfigMapsResponse_FieldPath(rawField string) ListConfigMapsResponse_FieldPath {
	fp, err := ParseListConfigMapsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListConfigMapsResponse_FieldTerminalPath struct {
	selector ListConfigMapsResponse_FieldPathSelector
}

var _ ListConfigMapsResponse_FieldPath = (*ListConfigMapsResponse_FieldTerminalPath)(nil)

func (fp *ListConfigMapsResponse_FieldTerminalPath) Selector() ListConfigMapsResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListConfigMapsResponse
func (fp *ListConfigMapsResponse_FieldTerminalPath) Get(source *ListConfigMapsResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
			for _, value := range source.GetConfigMaps() {
				values = append(values, value)
			}
		case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
			if source.PrevPageToken != nil {
				values = append(values, source.PrevPageToken)
			}
		case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
			if source.NextPageToken != nil {
				values = append(values, source.NextPageToken)
			}
		case ListConfigMapsResponse_FieldPathSelectorCurrentOffset:
			values = append(values, source.CurrentOffset)
		case ListConfigMapsResponse_FieldPathSelectorTotalResultsCount:
			values = append(values, source.TotalResultsCount)
		default:
			panic(fmt.Sprintf("Invalid selector for ListConfigMapsResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListConfigMapsResponse
func (fp *ListConfigMapsResponse_FieldTerminalPath) GetSingle(source *ListConfigMapsResponse) (interface{}, bool) {
	switch fp.selector {
	case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
		res := source.GetConfigMaps()
		return res, res != nil
	case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
		res := source.GetPrevPageToken()
		return res, res != nil
	case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
		res := source.GetNextPageToken()
		return res, res != nil
	case ListConfigMapsResponse_FieldPathSelectorCurrentOffset:
		return source.GetCurrentOffset(), source != nil
	case ListConfigMapsResponse_FieldPathSelectorTotalResultsCount:
		return source.GetTotalResultsCount(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListConfigMapsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
		return ([]*config_map.ConfigMap)(nil)
	case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
		return (*config_map.PagerCursor)(nil)
	case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
		return (*config_map.PagerCursor)(nil)
	case ListConfigMapsResponse_FieldPathSelectorCurrentOffset:
		return int32(0)
	case ListConfigMapsResponse_FieldPathSelectorTotalResultsCount:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsResponse: %d", fp.selector))
	}
}

func (fp *ListConfigMapsResponse_FieldTerminalPath) ClearValue(item *ListConfigMapsResponse) {
	if item != nil {
		switch fp.selector {
		case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
			item.ConfigMaps = nil
		case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		case ListConfigMapsResponse_FieldPathSelectorCurrentOffset:
			item.CurrentOffset = int32(0)
		case ListConfigMapsResponse_FieldPathSelectorTotalResultsCount:
			item.TotalResultsCount = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for ListConfigMapsResponse: %d", fp.selector))
		}
	}
}

func (fp *ListConfigMapsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListConfigMapsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListConfigMapsResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListConfigMapsResponse_FieldPathSelectorPrevPageToken ||
		fp.selector == ListConfigMapsResponse_FieldPathSelectorNextPageToken ||
		fp.selector == ListConfigMapsResponse_FieldPathSelectorCurrentOffset ||
		fp.selector == ListConfigMapsResponse_FieldPathSelectorTotalResultsCount
}

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

func (fp *ListConfigMapsResponse_FieldTerminalPath) WithIValue(value interface{}) ListConfigMapsResponse_FieldPathValue {
	switch fp.selector {
	case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
		return &ListConfigMapsResponse_FieldTerminalPathValue{ListConfigMapsResponse_FieldTerminalPath: *fp, value: value.([]*config_map.ConfigMap)}
	case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
		return &ListConfigMapsResponse_FieldTerminalPathValue{ListConfigMapsResponse_FieldTerminalPath: *fp, value: value.(*config_map.PagerCursor)}
	case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
		return &ListConfigMapsResponse_FieldTerminalPathValue{ListConfigMapsResponse_FieldTerminalPath: *fp, value: value.(*config_map.PagerCursor)}
	case ListConfigMapsResponse_FieldPathSelectorCurrentOffset:
		return &ListConfigMapsResponse_FieldTerminalPathValue{ListConfigMapsResponse_FieldTerminalPath: *fp, value: value.(int32)}
	case ListConfigMapsResponse_FieldPathSelectorTotalResultsCount:
		return &ListConfigMapsResponse_FieldTerminalPathValue{ListConfigMapsResponse_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsResponse: %d", fp.selector))
	}
}

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

func (fp *ListConfigMapsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListConfigMapsResponse_FieldPathArrayOfValues {
	fpaov := &ListConfigMapsResponse_FieldTerminalPathArrayOfValues{ListConfigMapsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
		return &ListConfigMapsResponse_FieldTerminalPathArrayOfValues{ListConfigMapsResponse_FieldTerminalPath: *fp, values: values.([][]*config_map.ConfigMap)}
	case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
		return &ListConfigMapsResponse_FieldTerminalPathArrayOfValues{ListConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]*config_map.PagerCursor)}
	case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
		return &ListConfigMapsResponse_FieldTerminalPathArrayOfValues{ListConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]*config_map.PagerCursor)}
	case ListConfigMapsResponse_FieldPathSelectorCurrentOffset:
		return &ListConfigMapsResponse_FieldTerminalPathArrayOfValues{ListConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListConfigMapsResponse_FieldPathSelectorTotalResultsCount:
		return &ListConfigMapsResponse_FieldTerminalPathArrayOfValues{ListConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *ListConfigMapsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListConfigMapsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
		return &ListConfigMapsResponse_FieldTerminalPathArrayItemValue{ListConfigMapsResponse_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsResponse: %d", fp.selector))
	}
}

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

type ListConfigMapsResponse_FieldSubPath struct {
	selector ListConfigMapsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListConfigMapsResponse_FieldPath = (*ListConfigMapsResponse_FieldSubPath)(nil)

func (fps *ListConfigMapsResponse_FieldSubPath) Selector() ListConfigMapsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ListConfigMapsResponse_FieldSubPath) AsConfigMapsSubPath() (config_map.ConfigMap_FieldPath, bool) {
	res, ok := fps.subPath.(config_map.ConfigMap_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *ListConfigMapsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListConfigMapsResponse))
}

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

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

func (fps *ListConfigMapsResponse_FieldSubPath) WithIValue(value interface{}) ListConfigMapsResponse_FieldPathValue {
	return &ListConfigMapsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ListConfigMapsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ListConfigMapsResponse_FieldPathArrayOfValues {
	return &ListConfigMapsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ListConfigMapsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ListConfigMapsResponse_FieldPathArrayItemValue {
	return &ListConfigMapsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseListConfigMapsResponse_FieldPathValue(pathStr, valueStr string) ListConfigMapsResponse_FieldPathValue {
	fpv, err := ParseListConfigMapsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListConfigMapsResponse_FieldTerminalPathValue struct {
	ListConfigMapsResponse_FieldTerminalPath
	value interface{}
}

var _ ListConfigMapsResponse_FieldPathValue = (*ListConfigMapsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListConfigMapsResponse' as interface{}
func (fpv *ListConfigMapsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListConfigMapsResponse_FieldTerminalPathValue) AsConfigMapsValue() ([]*config_map.ConfigMap, bool) {
	res, ok := fpv.value.([]*config_map.ConfigMap)
	return res, ok
}
func (fpv *ListConfigMapsResponse_FieldTerminalPathValue) AsPrevPageTokenValue() (*config_map.PagerCursor, bool) {
	res, ok := fpv.value.(*config_map.PagerCursor)
	return res, ok
}
func (fpv *ListConfigMapsResponse_FieldTerminalPathValue) AsNextPageTokenValue() (*config_map.PagerCursor, bool) {
	res, ok := fpv.value.(*config_map.PagerCursor)
	return res, ok
}
func (fpv *ListConfigMapsResponse_FieldTerminalPathValue) AsCurrentOffsetValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListConfigMapsResponse_FieldTerminalPathValue) AsTotalResultsCountValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object ListConfigMapsResponse
func (fpv *ListConfigMapsResponse_FieldTerminalPathValue) SetTo(target **ListConfigMapsResponse) {
	if *target == nil {
		*target = new(ListConfigMapsResponse)
	}
	switch fpv.selector {
	case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
		(*target).ConfigMaps = fpv.value.([]*config_map.ConfigMap)
	case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*config_map.PagerCursor)
	case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*config_map.PagerCursor)
	case ListConfigMapsResponse_FieldPathSelectorCurrentOffset:
		(*target).CurrentOffset = fpv.value.(int32)
	case ListConfigMapsResponse_FieldPathSelectorTotalResultsCount:
		(*target).TotalResultsCount = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for ListConfigMapsResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListConfigMapsResponse_FieldTerminalPathValue' with the value under path in 'ListConfigMapsResponse'.
func (fpv *ListConfigMapsResponse_FieldTerminalPathValue) CompareWith(source *ListConfigMapsResponse) (int, bool) {
	switch fpv.selector {
	case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
		return 0, false
	case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
		return 0, false
	case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
		return 0, false
	case ListConfigMapsResponse_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 ListConfigMapsResponse_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 ListConfigMapsResponse: %d", fpv.selector))
	}
}

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

type ListConfigMapsResponse_FieldSubPathValue struct {
	ListConfigMapsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListConfigMapsResponse_FieldPathValue = (*ListConfigMapsResponse_FieldSubPathValue)(nil)

func (fpvs *ListConfigMapsResponse_FieldSubPathValue) AsConfigMapsPathValue() (config_map.ConfigMap_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseListConfigMapsResponse_FieldPathArrayItemValue(pathStr, valueStr string) ListConfigMapsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseListConfigMapsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListConfigMapsResponse_FieldTerminalPathArrayItemValue struct {
	ListConfigMapsResponse_FieldTerminalPath
	value interface{}
}

var _ ListConfigMapsResponse_FieldPathArrayItemValue = (*ListConfigMapsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListConfigMapsResponse as interface{}
func (fpaiv *ListConfigMapsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ListConfigMapsResponse_FieldTerminalPathArrayItemValue) AsConfigMapsItemValue() (*config_map.ConfigMap, bool) {
	res, ok := fpaiv.value.(*config_map.ConfigMap)
	return res, ok
}

func (fpaiv *ListConfigMapsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ListConfigMapsResponse) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ListConfigMapsResponse'
func (fpaiv *ListConfigMapsResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *ListConfigMapsResponse) bool {
	slice := fpaiv.ListConfigMapsResponse_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 ListConfigMapsResponse_FieldSubPathArrayItemValue struct {
	ListConfigMapsResponse_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ListConfigMapsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListConfigMapsResponse_FieldSubPathArrayItemValue) AsConfigMapsPathItemValue() (config_map.ConfigMap_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(config_map.ConfigMap_FieldPathArrayItemValue)
	return res, ok
}

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

// ListConfigMapsResponse_FieldPathArrayOfValues allows storing slice of values for ListConfigMapsResponse fields according to their type
type ListConfigMapsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListConfigMapsResponse_FieldPath
}

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

func MustParseListConfigMapsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ListConfigMapsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseListConfigMapsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListConfigMapsResponse_FieldTerminalPathArrayOfValues struct {
	ListConfigMapsResponse_FieldTerminalPath
	values interface{}
}

var _ ListConfigMapsResponse_FieldPathArrayOfValues = (*ListConfigMapsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListConfigMapsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListConfigMapsResponse_FieldPathSelectorConfigMaps:
		for _, v := range fpaov.values.([][]*config_map.ConfigMap) {
			values = append(values, v)
		}
	case ListConfigMapsResponse_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*config_map.PagerCursor) {
			values = append(values, v)
		}
	case ListConfigMapsResponse_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*config_map.PagerCursor) {
			values = append(values, v)
		}
	case ListConfigMapsResponse_FieldPathSelectorCurrentOffset:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListConfigMapsResponse_FieldPathSelectorTotalResultsCount:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListConfigMapsResponse_FieldTerminalPathArrayOfValues) AsConfigMapsArrayOfValues() ([][]*config_map.ConfigMap, bool) {
	res, ok := fpaov.values.([][]*config_map.ConfigMap)
	return res, ok
}
func (fpaov *ListConfigMapsResponse_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*config_map.PagerCursor, bool) {
	res, ok := fpaov.values.([]*config_map.PagerCursor)
	return res, ok
}
func (fpaov *ListConfigMapsResponse_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*config_map.PagerCursor, bool) {
	res, ok := fpaov.values.([]*config_map.PagerCursor)
	return res, ok
}
func (fpaov *ListConfigMapsResponse_FieldTerminalPathArrayOfValues) AsCurrentOffsetArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListConfigMapsResponse_FieldTerminalPathArrayOfValues) AsTotalResultsCountArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

type ListConfigMapsResponse_FieldSubPathArrayOfValues struct {
	ListConfigMapsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListConfigMapsResponse_FieldPathArrayOfValues = (*ListConfigMapsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListConfigMapsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListConfigMapsResponse_FieldSubPathArrayOfValues) AsConfigMapsPathArrayOfValues() (config_map.ConfigMap_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(config_map.ConfigMap_FieldPathArrayOfValues)
	return res, ok
}

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

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

type WatchConfigMapRequest_FieldPathSelector int32

const (
	WatchConfigMapRequest_FieldPathSelectorName      WatchConfigMapRequest_FieldPathSelector = 0
	WatchConfigMapRequest_FieldPathSelectorFieldMask WatchConfigMapRequest_FieldPathSelector = 1
	WatchConfigMapRequest_FieldPathSelectorView      WatchConfigMapRequest_FieldPathSelector = 2
)

func (s WatchConfigMapRequest_FieldPathSelector) String() string {
	switch s {
	case WatchConfigMapRequest_FieldPathSelectorName:
		return "name"
	case WatchConfigMapRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchConfigMapRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapRequest: %d", s))
	}
}

func BuildWatchConfigMapRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchConfigMapRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchConfigMapRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &WatchConfigMapRequest_FieldTerminalPath{selector: WatchConfigMapRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchConfigMapRequest_FieldTerminalPath{selector: WatchConfigMapRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchConfigMapRequest_FieldTerminalPath{selector: WatchConfigMapRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchConfigMapRequest", fp)
}

func ParseWatchConfigMapRequest_FieldPath(rawField string) (WatchConfigMapRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConfigMapRequest_FieldPath(fp)
}

func MustParseWatchConfigMapRequest_FieldPath(rawField string) WatchConfigMapRequest_FieldPath {
	fp, err := ParseWatchConfigMapRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConfigMapRequest_FieldTerminalPath struct {
	selector WatchConfigMapRequest_FieldPathSelector
}

var _ WatchConfigMapRequest_FieldPath = (*WatchConfigMapRequest_FieldTerminalPath)(nil)

func (fp *WatchConfigMapRequest_FieldTerminalPath) Selector() WatchConfigMapRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchConfigMapRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConfigMapRequest_FieldPathSelectorName:
		return (*config_map.Reference)(nil)
	case WatchConfigMapRequest_FieldPathSelectorFieldMask:
		return (*config_map.ConfigMap_FieldMask)(nil)
	case WatchConfigMapRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapRequest: %d", fp.selector))
	}
}

func (fp *WatchConfigMapRequest_FieldTerminalPath) ClearValue(item *WatchConfigMapRequest) {
	if item != nil {
		switch fp.selector {
		case WatchConfigMapRequest_FieldPathSelectorName:
			item.Name = nil
		case WatchConfigMapRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchConfigMapRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConfigMapRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchConfigMapRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConfigMapRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchConfigMapRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchConfigMapRequest_FieldPathSelectorName ||
		fp.selector == WatchConfigMapRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchConfigMapRequest_FieldPathSelectorView
}

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

func (fp *WatchConfigMapRequest_FieldTerminalPath) WithIValue(value interface{}) WatchConfigMapRequest_FieldPathValue {
	switch fp.selector {
	case WatchConfigMapRequest_FieldPathSelectorName:
		return &WatchConfigMapRequest_FieldTerminalPathValue{WatchConfigMapRequest_FieldTerminalPath: *fp, value: value.(*config_map.Reference)}
	case WatchConfigMapRequest_FieldPathSelectorFieldMask:
		return &WatchConfigMapRequest_FieldTerminalPathValue{WatchConfigMapRequest_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap_FieldMask)}
	case WatchConfigMapRequest_FieldPathSelectorView:
		return &WatchConfigMapRequest_FieldTerminalPathValue{WatchConfigMapRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapRequest: %d", fp.selector))
	}
}

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

func (fp *WatchConfigMapRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConfigMapRequest_FieldPathArrayOfValues {
	fpaov := &WatchConfigMapRequest_FieldTerminalPathArrayOfValues{WatchConfigMapRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConfigMapRequest_FieldPathSelectorName:
		return &WatchConfigMapRequest_FieldTerminalPathArrayOfValues{WatchConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*config_map.Reference)}
	case WatchConfigMapRequest_FieldPathSelectorFieldMask:
		return &WatchConfigMapRequest_FieldTerminalPathArrayOfValues{WatchConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap_FieldMask)}
	case WatchConfigMapRequest_FieldPathSelectorView:
		return &WatchConfigMapRequest_FieldTerminalPathArrayOfValues{WatchConfigMapRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchConfigMapRequest_FieldPathValue(pathStr, valueStr string) WatchConfigMapRequest_FieldPathValue {
	fpv, err := ParseWatchConfigMapRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConfigMapRequest_FieldTerminalPathValue struct {
	WatchConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapRequest_FieldPathValue = (*WatchConfigMapRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object WatchConfigMapRequest
func (fpv *WatchConfigMapRequest_FieldTerminalPathValue) SetTo(target **WatchConfigMapRequest) {
	if *target == nil {
		*target = new(WatchConfigMapRequest)
	}
	switch fpv.selector {
	case WatchConfigMapRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*config_map.Reference)
	case WatchConfigMapRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*config_map.ConfigMap_FieldMask)
	case WatchConfigMapRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchConfigMapRequest_FieldTerminalPathValue' with the value under path in 'WatchConfigMapRequest'.
func (fpv *WatchConfigMapRequest_FieldTerminalPathValue) CompareWith(source *WatchConfigMapRequest) (int, bool) {
	switch fpv.selector {
	case WatchConfigMapRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*config_map.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 WatchConfigMapRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchConfigMapRequest_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 WatchConfigMapRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchConfigMapRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConfigMapRequest_FieldTerminalPathArrayItemValue struct {
	WatchConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapRequest_FieldPathArrayItemValue = (*WatchConfigMapRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchConfigMapRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConfigMapRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'WatchConfigMapRequest'
func (fpaiv *WatchConfigMapRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConfigMapRequest) bool {
	slice := fpaiv.WatchConfigMapRequest_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
}

// WatchConfigMapRequest_FieldPathArrayOfValues allows storing slice of values for WatchConfigMapRequest fields according to their type
type WatchConfigMapRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchConfigMapRequest_FieldPath
}

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

func MustParseWatchConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConfigMapRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConfigMapRequest_FieldTerminalPathArrayOfValues struct {
	WatchConfigMapRequest_FieldTerminalPath
	values interface{}
}

var _ WatchConfigMapRequest_FieldPathArrayOfValues = (*WatchConfigMapRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConfigMapRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConfigMapRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*config_map.Reference) {
			values = append(values, v)
		}
	case WatchConfigMapRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*config_map.ConfigMap_FieldMask) {
			values = append(values, v)
		}
	case WatchConfigMapRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConfigMapRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*config_map.Reference, bool) {
	res, ok := fpaov.values.([]*config_map.Reference)
	return res, ok
}
func (fpaov *WatchConfigMapRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*config_map.ConfigMap_FieldMask, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap_FieldMask)
	return res, ok
}
func (fpaov *WatchConfigMapRequest_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 WatchConfigMapResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchConfigMapResponse_FieldPathSelector
	Get(source *WatchConfigMapResponse) []interface{}
	GetSingle(source *WatchConfigMapResponse) (interface{}, bool)
	ClearValue(item *WatchConfigMapResponse)

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

type WatchConfigMapResponse_FieldPathSelector int32

const (
	WatchConfigMapResponse_FieldPathSelectorChange WatchConfigMapResponse_FieldPathSelector = 0
)

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

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

func ParseWatchConfigMapResponse_FieldPath(rawField string) (WatchConfigMapResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConfigMapResponse_FieldPath(fp)
}

func MustParseWatchConfigMapResponse_FieldPath(rawField string) WatchConfigMapResponse_FieldPath {
	fp, err := ParseWatchConfigMapResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConfigMapResponse_FieldTerminalPath struct {
	selector WatchConfigMapResponse_FieldPathSelector
}

var _ WatchConfigMapResponse_FieldPath = (*WatchConfigMapResponse_FieldTerminalPath)(nil)

func (fp *WatchConfigMapResponse_FieldTerminalPath) Selector() WatchConfigMapResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchConfigMapResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConfigMapResponse_FieldPathSelectorChange:
		return (*config_map.ConfigMapChange)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapResponse: %d", fp.selector))
	}
}

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

func (fp *WatchConfigMapResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConfigMapResponse))
}

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

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

func (fp *WatchConfigMapResponse_FieldTerminalPath) WithIValue(value interface{}) WatchConfigMapResponse_FieldPathValue {
	switch fp.selector {
	case WatchConfigMapResponse_FieldPathSelectorChange:
		return &WatchConfigMapResponse_FieldTerminalPathValue{WatchConfigMapResponse_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMapChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapResponse: %d", fp.selector))
	}
}

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

func (fp *WatchConfigMapResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConfigMapResponse_FieldPathArrayOfValues {
	fpaov := &WatchConfigMapResponse_FieldTerminalPathArrayOfValues{WatchConfigMapResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConfigMapResponse_FieldPathSelectorChange:
		return &WatchConfigMapResponse_FieldTerminalPathArrayOfValues{WatchConfigMapResponse_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMapChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchConfigMapResponse_FieldPathValue(pathStr, valueStr string) WatchConfigMapResponse_FieldPathValue {
	fpv, err := ParseWatchConfigMapResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConfigMapResponse_FieldTerminalPathValue struct {
	WatchConfigMapResponse_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapResponse_FieldPathValue = (*WatchConfigMapResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchConfigMapResponse' as interface{}
func (fpv *WatchConfigMapResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchConfigMapResponse_FieldTerminalPathValue) AsChangeValue() (*config_map.ConfigMapChange, bool) {
	res, ok := fpv.value.(*config_map.ConfigMapChange)
	return res, ok
}

// SetTo stores value for selected field for object WatchConfigMapResponse
func (fpv *WatchConfigMapResponse_FieldTerminalPathValue) SetTo(target **WatchConfigMapResponse) {
	if *target == nil {
		*target = new(WatchConfigMapResponse)
	}
	switch fpv.selector {
	case WatchConfigMapResponse_FieldPathSelectorChange:
		(*target).Change = fpv.value.(*config_map.ConfigMapChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapResponse: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseWatchConfigMapResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchConfigMapResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConfigMapResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConfigMapResponse_FieldTerminalPathArrayItemValue struct {
	WatchConfigMapResponse_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapResponse_FieldPathArrayItemValue = (*WatchConfigMapResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchConfigMapResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConfigMapResponse) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'WatchConfigMapResponse'
func (fpaiv *WatchConfigMapResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConfigMapResponse) bool {
	slice := fpaiv.WatchConfigMapResponse_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
}

// WatchConfigMapResponse_FieldPathArrayOfValues allows storing slice of values for WatchConfigMapResponse fields according to their type
type WatchConfigMapResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchConfigMapResponse_FieldPath
}

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

func MustParseWatchConfigMapResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConfigMapResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConfigMapResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConfigMapResponse_FieldTerminalPathArrayOfValues struct {
	WatchConfigMapResponse_FieldTerminalPath
	values interface{}
}

var _ WatchConfigMapResponse_FieldPathArrayOfValues = (*WatchConfigMapResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConfigMapResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConfigMapResponse_FieldPathSelectorChange:
		for _, v := range fpaov.values.([]*config_map.ConfigMapChange) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConfigMapResponse_FieldTerminalPathArrayOfValues) AsChangeArrayOfValues() ([]*config_map.ConfigMapChange, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMapChange)
	return res, ok
}

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

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

type WatchConfigMapsRequest_FieldPathSelector int32

const (
	WatchConfigMapsRequest_FieldPathSelectorType         WatchConfigMapsRequest_FieldPathSelector = 0
	WatchConfigMapsRequest_FieldPathSelectorParent       WatchConfigMapsRequest_FieldPathSelector = 1
	WatchConfigMapsRequest_FieldPathSelectorPageSize     WatchConfigMapsRequest_FieldPathSelector = 2
	WatchConfigMapsRequest_FieldPathSelectorPageToken    WatchConfigMapsRequest_FieldPathSelector = 3
	WatchConfigMapsRequest_FieldPathSelectorOrderBy      WatchConfigMapsRequest_FieldPathSelector = 4
	WatchConfigMapsRequest_FieldPathSelectorResumeToken  WatchConfigMapsRequest_FieldPathSelector = 5
	WatchConfigMapsRequest_FieldPathSelectorStartingTime WatchConfigMapsRequest_FieldPathSelector = 6
	WatchConfigMapsRequest_FieldPathSelectorFilter       WatchConfigMapsRequest_FieldPathSelector = 7
	WatchConfigMapsRequest_FieldPathSelectorFieldMask    WatchConfigMapsRequest_FieldPathSelector = 8
	WatchConfigMapsRequest_FieldPathSelectorView         WatchConfigMapsRequest_FieldPathSelector = 9
	WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize WatchConfigMapsRequest_FieldPathSelector = 10
)

func (s WatchConfigMapsRequest_FieldPathSelector) String() string {
	switch s {
	case WatchConfigMapsRequest_FieldPathSelectorType:
		return "type"
	case WatchConfigMapsRequest_FieldPathSelectorParent:
		return "parent"
	case WatchConfigMapsRequest_FieldPathSelectorPageSize:
		return "page_size"
	case WatchConfigMapsRequest_FieldPathSelectorPageToken:
		return "page_token"
	case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case WatchConfigMapsRequest_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchConfigMapsRequest_FieldPathSelectorStartingTime:
		return "starting_time"
	case WatchConfigMapsRequest_FieldPathSelectorFilter:
		return "filter"
	case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchConfigMapsRequest_FieldPathSelectorView:
		return "view"
	case WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize:
		return "max_chunk_size"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsRequest: %d", s))
	}
}

func BuildWatchConfigMapsRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchConfigMapsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchConfigMapsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorType}, nil
		case "parent":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorOrderBy}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorResumeToken}, nil
		case "starting_time", "startingTime", "starting-time":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorStartingTime}, nil
		case "filter":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorView}, nil
		case "max_chunk_size", "maxChunkSize", "max-chunk-size":
			return &WatchConfigMapsRequest_FieldTerminalPath{selector: WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchConfigMapsRequest", fp)
}

func ParseWatchConfigMapsRequest_FieldPath(rawField string) (WatchConfigMapsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConfigMapsRequest_FieldPath(fp)
}

func MustParseWatchConfigMapsRequest_FieldPath(rawField string) WatchConfigMapsRequest_FieldPath {
	fp, err := ParseWatchConfigMapsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConfigMapsRequest_FieldTerminalPath struct {
	selector WatchConfigMapsRequest_FieldPathSelector
}

var _ WatchConfigMapsRequest_FieldPath = (*WatchConfigMapsRequest_FieldTerminalPath)(nil)

func (fp *WatchConfigMapsRequest_FieldTerminalPath) Selector() WatchConfigMapsRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchConfigMapsRequest
func (fp *WatchConfigMapsRequest_FieldTerminalPath) Get(source *WatchConfigMapsRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchConfigMapsRequest_FieldPathSelectorType:
			values = append(values, source.Type)
		case WatchConfigMapsRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case WatchConfigMapsRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case WatchConfigMapsRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case WatchConfigMapsRequest_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchConfigMapsRequest_FieldPathSelectorStartingTime:
			if source.StartingTime != nil {
				values = append(values, source.StartingTime)
			}
		case WatchConfigMapsRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchConfigMapsRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize:
			values = append(values, source.MaxChunkSize)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConfigMapsRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchConfigMapsRequest
func (fp *WatchConfigMapsRequest_FieldTerminalPath) GetSingle(source *WatchConfigMapsRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchConfigMapsRequest_FieldPathSelectorType:
		return source.GetType(), source != nil
	case WatchConfigMapsRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case WatchConfigMapsRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case WatchConfigMapsRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case WatchConfigMapsRequest_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchConfigMapsRequest_FieldPathSelectorStartingTime:
		res := source.GetStartingTime()
		return res, res != nil
	case WatchConfigMapsRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchConfigMapsRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize:
		return source.GetMaxChunkSize(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchConfigMapsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConfigMapsRequest_FieldPathSelectorType:
		return watch_type.WatchType_STATEFUL
	case WatchConfigMapsRequest_FieldPathSelectorParent:
		return (*config_map.ParentReference)(nil)
	case WatchConfigMapsRequest_FieldPathSelectorPageSize:
		return int32(0)
	case WatchConfigMapsRequest_FieldPathSelectorPageToken:
		return (*config_map.PagerCursor)(nil)
	case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
		return (*config_map.OrderBy)(nil)
	case WatchConfigMapsRequest_FieldPathSelectorResumeToken:
		return ""
	case WatchConfigMapsRequest_FieldPathSelectorStartingTime:
		return (*timestamp.Timestamp)(nil)
	case WatchConfigMapsRequest_FieldPathSelectorFilter:
		return (*config_map.Filter)(nil)
	case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
		return (*config_map.ConfigMap_FieldMask)(nil)
	case WatchConfigMapsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsRequest: %d", fp.selector))
	}
}

func (fp *WatchConfigMapsRequest_FieldTerminalPath) ClearValue(item *WatchConfigMapsRequest) {
	if item != nil {
		switch fp.selector {
		case WatchConfigMapsRequest_FieldPathSelectorType:
			item.Type = watch_type.WatchType_STATEFUL
		case WatchConfigMapsRequest_FieldPathSelectorParent:
			item.Parent = nil
		case WatchConfigMapsRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case WatchConfigMapsRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case WatchConfigMapsRequest_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchConfigMapsRequest_FieldPathSelectorStartingTime:
			item.StartingTime = nil
		case WatchConfigMapsRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchConfigMapsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize:
			item.MaxChunkSize = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConfigMapsRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchConfigMapsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConfigMapsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchConfigMapsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchConfigMapsRequest_FieldPathSelectorType ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorParent ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorPageSize ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorPageToken ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorOrderBy ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorResumeToken ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorStartingTime ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorFilter ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorView ||
		fp.selector == WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize
}

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

func (fp *WatchConfigMapsRequest_FieldTerminalPath) WithIValue(value interface{}) WatchConfigMapsRequest_FieldPathValue {
	switch fp.selector {
	case WatchConfigMapsRequest_FieldPathSelectorType:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(watch_type.WatchType)}
	case WatchConfigMapsRequest_FieldPathSelectorParent:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.ParentReference)}
	case WatchConfigMapsRequest_FieldPathSelectorPageSize:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case WatchConfigMapsRequest_FieldPathSelectorPageToken:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.PagerCursor)}
	case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.OrderBy)}
	case WatchConfigMapsRequest_FieldPathSelectorResumeToken:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(string)}
	case WatchConfigMapsRequest_FieldPathSelectorStartingTime:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*timestamp.Timestamp)}
	case WatchConfigMapsRequest_FieldPathSelectorFilter:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.Filter)}
	case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap_FieldMask)}
	case WatchConfigMapsRequest_FieldPathSelectorView:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize:
		return &WatchConfigMapsRequest_FieldTerminalPathValue{WatchConfigMapsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsRequest: %d", fp.selector))
	}
}

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

func (fp *WatchConfigMapsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConfigMapsRequest_FieldPathArrayOfValues {
	fpaov := &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConfigMapsRequest_FieldPathSelectorType:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]watch_type.WatchType)}
	case WatchConfigMapsRequest_FieldPathSelectorParent:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ParentReference)}
	case WatchConfigMapsRequest_FieldPathSelectorPageSize:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case WatchConfigMapsRequest_FieldPathSelectorPageToken:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.PagerCursor)}
	case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.OrderBy)}
	case WatchConfigMapsRequest_FieldPathSelectorResumeToken:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchConfigMapsRequest_FieldPathSelectorStartingTime:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*timestamp.Timestamp)}
	case WatchConfigMapsRequest_FieldPathSelectorFilter:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.Filter)}
	case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap_FieldMask)}
	case WatchConfigMapsRequest_FieldPathSelectorView:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize:
		return &WatchConfigMapsRequest_FieldTerminalPathArrayOfValues{WatchConfigMapsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchConfigMapsRequest_FieldPathValue(pathStr, valueStr string) WatchConfigMapsRequest_FieldPathValue {
	fpv, err := ParseWatchConfigMapsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConfigMapsRequest_FieldTerminalPathValue struct {
	WatchConfigMapsRequest_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapsRequest_FieldPathValue = (*WatchConfigMapsRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object WatchConfigMapsRequest
func (fpv *WatchConfigMapsRequest_FieldTerminalPathValue) SetTo(target **WatchConfigMapsRequest) {
	if *target == nil {
		*target = new(WatchConfigMapsRequest)
	}
	switch fpv.selector {
	case WatchConfigMapsRequest_FieldPathSelectorType:
		(*target).Type = fpv.value.(watch_type.WatchType)
	case WatchConfigMapsRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*config_map.ParentReference)
	case WatchConfigMapsRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case WatchConfigMapsRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*config_map.PagerCursor)
	case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*config_map.OrderBy)
	case WatchConfigMapsRequest_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchConfigMapsRequest_FieldPathSelectorStartingTime:
		(*target).StartingTime = fpv.value.(*timestamp.Timestamp)
	case WatchConfigMapsRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*config_map.Filter)
	case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*config_map.ConfigMap_FieldMask)
	case WatchConfigMapsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize:
		(*target).MaxChunkSize = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchConfigMapsRequest_FieldTerminalPathValue' with the value under path in 'WatchConfigMapsRequest'.
func (fpv *WatchConfigMapsRequest_FieldTerminalPathValue) CompareWith(source *WatchConfigMapsRequest) (int, bool) {
	switch fpv.selector {
	case WatchConfigMapsRequest_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 WatchConfigMapsRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*config_map.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 WatchConfigMapsRequest_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 WatchConfigMapsRequest_FieldPathSelectorPageToken:
		return 0, false
	case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
		return 0, false
	case WatchConfigMapsRequest_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 WatchConfigMapsRequest_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 WatchConfigMapsRequest_FieldPathSelectorFilter:
		return 0, false
	case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchConfigMapsRequest_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 WatchConfigMapsRequest_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 WatchConfigMapsRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchConfigMapsRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchConfigMapsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConfigMapsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConfigMapsRequest_FieldTerminalPathArrayItemValue struct {
	WatchConfigMapsRequest_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapsRequest_FieldPathArrayItemValue = (*WatchConfigMapsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchConfigMapsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConfigMapsRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'WatchConfigMapsRequest'
func (fpaiv *WatchConfigMapsRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConfigMapsRequest) bool {
	slice := fpaiv.WatchConfigMapsRequest_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
}

// WatchConfigMapsRequest_FieldPathArrayOfValues allows storing slice of values for WatchConfigMapsRequest fields according to their type
type WatchConfigMapsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchConfigMapsRequest_FieldPath
}

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

func MustParseWatchConfigMapsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConfigMapsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConfigMapsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConfigMapsRequest_FieldTerminalPathArrayOfValues struct {
	WatchConfigMapsRequest_FieldTerminalPath
	values interface{}
}

var _ WatchConfigMapsRequest_FieldPathArrayOfValues = (*WatchConfigMapsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConfigMapsRequest_FieldPathSelectorType:
		for _, v := range fpaov.values.([]watch_type.WatchType) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*config_map.ParentReference) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*config_map.PagerCursor) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*config_map.OrderBy) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorStartingTime:
		for _, v := range fpaov.values.([]*timestamp.Timestamp) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*config_map.Filter) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*config_map.ConfigMap_FieldMask) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case WatchConfigMapsRequest_FieldPathSelectorMaxChunkSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]watch_type.WatchType, bool) {
	res, ok := fpaov.values.([]watch_type.WatchType)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*config_map.ParentReference, bool) {
	res, ok := fpaov.values.([]*config_map.ParentReference)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*config_map.PagerCursor, bool) {
	res, ok := fpaov.values.([]*config_map.PagerCursor)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*config_map.OrderBy, bool) {
	res, ok := fpaov.values.([]*config_map.OrderBy)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsStartingTimeArrayOfValues() ([]*timestamp.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamp.Timestamp)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*config_map.Filter, bool) {
	res, ok := fpaov.values.([]*config_map.Filter)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*config_map.ConfigMap_FieldMask, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap_FieldMask)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *WatchConfigMapsRequest_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 WatchConfigMapsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchConfigMapsResponse_FieldPathSelector
	Get(source *WatchConfigMapsResponse) []interface{}
	GetSingle(source *WatchConfigMapsResponse) (interface{}, bool)
	ClearValue(item *WatchConfigMapsResponse)

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

type WatchConfigMapsResponse_FieldPathSelector int32

const (
	WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges WatchConfigMapsResponse_FieldPathSelector = 0
	WatchConfigMapsResponse_FieldPathSelectorIsCurrent        WatchConfigMapsResponse_FieldPathSelector = 1
	WatchConfigMapsResponse_FieldPathSelectorPageTokenChange  WatchConfigMapsResponse_FieldPathSelector = 2
	WatchConfigMapsResponse_FieldPathSelectorResumeToken      WatchConfigMapsResponse_FieldPathSelector = 3
	WatchConfigMapsResponse_FieldPathSelectorSnapshotSize     WatchConfigMapsResponse_FieldPathSelector = 4
	WatchConfigMapsResponse_FieldPathSelectorIsSoftReset      WatchConfigMapsResponse_FieldPathSelector = 5
	WatchConfigMapsResponse_FieldPathSelectorIsHardReset      WatchConfigMapsResponse_FieldPathSelector = 6
)

func (s WatchConfigMapsResponse_FieldPathSelector) String() string {
	switch s {
	case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
		return "config_map_changes"
	case WatchConfigMapsResponse_FieldPathSelectorIsCurrent:
		return "is_current"
	case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
		return "page_token_change"
	case WatchConfigMapsResponse_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchConfigMapsResponse_FieldPathSelectorSnapshotSize:
		return "snapshot_size"
	case WatchConfigMapsResponse_FieldPathSelectorIsSoftReset:
		return "is_soft_reset"
	case WatchConfigMapsResponse_FieldPathSelectorIsHardReset:
		return "is_hard_reset"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", s))
	}
}

func BuildWatchConfigMapsResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchConfigMapsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchConfigMapsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "config_map_changes", "configMapChanges", "config-map-changes":
			return &WatchConfigMapsResponse_FieldTerminalPath{selector: WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges}, nil
		case "is_current", "isCurrent", "is-current":
			return &WatchConfigMapsResponse_FieldTerminalPath{selector: WatchConfigMapsResponse_FieldPathSelectorIsCurrent}, nil
		case "page_token_change", "pageTokenChange", "page-token-change":
			return &WatchConfigMapsResponse_FieldTerminalPath{selector: WatchConfigMapsResponse_FieldPathSelectorPageTokenChange}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchConfigMapsResponse_FieldTerminalPath{selector: WatchConfigMapsResponse_FieldPathSelectorResumeToken}, nil
		case "snapshot_size", "snapshotSize", "snapshot-size":
			return &WatchConfigMapsResponse_FieldTerminalPath{selector: WatchConfigMapsResponse_FieldPathSelectorSnapshotSize}, nil
		case "is_soft_reset", "isSoftReset", "is-soft-reset":
			return &WatchConfigMapsResponse_FieldTerminalPath{selector: WatchConfigMapsResponse_FieldPathSelectorIsSoftReset}, nil
		case "is_hard_reset", "isHardReset", "is-hard-reset":
			return &WatchConfigMapsResponse_FieldTerminalPath{selector: WatchConfigMapsResponse_FieldPathSelectorIsHardReset}, nil
		}
	} else {
		switch fp[0] {
		case "page_token_change", "pageTokenChange", "page-token-change":
			if subpath, err := BuildWatchConfigMapsResponsePageTokenChange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &WatchConfigMapsResponse_FieldSubPath{selector: WatchConfigMapsResponse_FieldPathSelectorPageTokenChange, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchConfigMapsResponse", fp)
}

func ParseWatchConfigMapsResponse_FieldPath(rawField string) (WatchConfigMapsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConfigMapsResponse_FieldPath(fp)
}

func MustParseWatchConfigMapsResponse_FieldPath(rawField string) WatchConfigMapsResponse_FieldPath {
	fp, err := ParseWatchConfigMapsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConfigMapsResponse_FieldTerminalPath struct {
	selector WatchConfigMapsResponse_FieldPathSelector
}

var _ WatchConfigMapsResponse_FieldPath = (*WatchConfigMapsResponse_FieldTerminalPath)(nil)

func (fp *WatchConfigMapsResponse_FieldTerminalPath) Selector() WatchConfigMapsResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchConfigMapsResponse
func (fp *WatchConfigMapsResponse_FieldTerminalPath) Get(source *WatchConfigMapsResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
			for _, value := range source.GetConfigMapChanges() {
				values = append(values, value)
			}
		case WatchConfigMapsResponse_FieldPathSelectorIsCurrent:
			values = append(values, source.IsCurrent)
		case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
			if source.PageTokenChange != nil {
				values = append(values, source.PageTokenChange)
			}
		case WatchConfigMapsResponse_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchConfigMapsResponse_FieldPathSelectorSnapshotSize:
			values = append(values, source.SnapshotSize)
		case WatchConfigMapsResponse_FieldPathSelectorIsSoftReset:
			values = append(values, source.IsSoftReset)
		case WatchConfigMapsResponse_FieldPathSelectorIsHardReset:
			values = append(values, source.IsHardReset)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchConfigMapsResponse
func (fp *WatchConfigMapsResponse_FieldTerminalPath) GetSingle(source *WatchConfigMapsResponse) (interface{}, bool) {
	switch fp.selector {
	case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
		res := source.GetConfigMapChanges()
		return res, res != nil
	case WatchConfigMapsResponse_FieldPathSelectorIsCurrent:
		return source.GetIsCurrent(), source != nil
	case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
		res := source.GetPageTokenChange()
		return res, res != nil
	case WatchConfigMapsResponse_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchConfigMapsResponse_FieldPathSelectorSnapshotSize:
		return source.GetSnapshotSize(), source != nil
	case WatchConfigMapsResponse_FieldPathSelectorIsSoftReset:
		return source.GetIsSoftReset(), source != nil
	case WatchConfigMapsResponse_FieldPathSelectorIsHardReset:
		return source.GetIsHardReset(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchConfigMapsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
		return ([]*config_map.ConfigMapChange)(nil)
	case WatchConfigMapsResponse_FieldPathSelectorIsCurrent:
		return false
	case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
		return (*WatchConfigMapsResponse_PageTokenChange)(nil)
	case WatchConfigMapsResponse_FieldPathSelectorResumeToken:
		return ""
	case WatchConfigMapsResponse_FieldPathSelectorSnapshotSize:
		return int64(0)
	case WatchConfigMapsResponse_FieldPathSelectorIsSoftReset:
		return false
	case WatchConfigMapsResponse_FieldPathSelectorIsHardReset:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", fp.selector))
	}
}

func (fp *WatchConfigMapsResponse_FieldTerminalPath) ClearValue(item *WatchConfigMapsResponse) {
	if item != nil {
		switch fp.selector {
		case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
			item.ConfigMapChanges = nil
		case WatchConfigMapsResponse_FieldPathSelectorIsCurrent:
			item.IsCurrent = false
		case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
			item.PageTokenChange = nil
		case WatchConfigMapsResponse_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchConfigMapsResponse_FieldPathSelectorSnapshotSize:
			item.SnapshotSize = int64(0)
		case WatchConfigMapsResponse_FieldPathSelectorIsSoftReset:
			item.IsSoftReset = false
		case WatchConfigMapsResponse_FieldPathSelectorIsHardReset:
			item.IsHardReset = false
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchConfigMapsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConfigMapsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchConfigMapsResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges ||
		fp.selector == WatchConfigMapsResponse_FieldPathSelectorIsCurrent ||
		fp.selector == WatchConfigMapsResponse_FieldPathSelectorResumeToken ||
		fp.selector == WatchConfigMapsResponse_FieldPathSelectorSnapshotSize ||
		fp.selector == WatchConfigMapsResponse_FieldPathSelectorIsSoftReset ||
		fp.selector == WatchConfigMapsResponse_FieldPathSelectorIsHardReset
}

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

func (fp *WatchConfigMapsResponse_FieldTerminalPath) WithIValue(value interface{}) WatchConfigMapsResponse_FieldPathValue {
	switch fp.selector {
	case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
		return &WatchConfigMapsResponse_FieldTerminalPathValue{WatchConfigMapsResponse_FieldTerminalPath: *fp, value: value.([]*config_map.ConfigMapChange)}
	case WatchConfigMapsResponse_FieldPathSelectorIsCurrent:
		return &WatchConfigMapsResponse_FieldTerminalPathValue{WatchConfigMapsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
		return &WatchConfigMapsResponse_FieldTerminalPathValue{WatchConfigMapsResponse_FieldTerminalPath: *fp, value: value.(*WatchConfigMapsResponse_PageTokenChange)}
	case WatchConfigMapsResponse_FieldPathSelectorResumeToken:
		return &WatchConfigMapsResponse_FieldTerminalPathValue{WatchConfigMapsResponse_FieldTerminalPath: *fp, value: value.(string)}
	case WatchConfigMapsResponse_FieldPathSelectorSnapshotSize:
		return &WatchConfigMapsResponse_FieldTerminalPathValue{WatchConfigMapsResponse_FieldTerminalPath: *fp, value: value.(int64)}
	case WatchConfigMapsResponse_FieldPathSelectorIsSoftReset:
		return &WatchConfigMapsResponse_FieldTerminalPathValue{WatchConfigMapsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchConfigMapsResponse_FieldPathSelectorIsHardReset:
		return &WatchConfigMapsResponse_FieldTerminalPathValue{WatchConfigMapsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", fp.selector))
	}
}

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

func (fp *WatchConfigMapsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConfigMapsResponse_FieldPathArrayOfValues {
	fpaov := &WatchConfigMapsResponse_FieldTerminalPathArrayOfValues{WatchConfigMapsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
		return &WatchConfigMapsResponse_FieldTerminalPathArrayOfValues{WatchConfigMapsResponse_FieldTerminalPath: *fp, values: values.([][]*config_map.ConfigMapChange)}
	case WatchConfigMapsResponse_FieldPathSelectorIsCurrent:
		return &WatchConfigMapsResponse_FieldTerminalPathArrayOfValues{WatchConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
		return &WatchConfigMapsResponse_FieldTerminalPathArrayOfValues{WatchConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]*WatchConfigMapsResponse_PageTokenChange)}
	case WatchConfigMapsResponse_FieldPathSelectorResumeToken:
		return &WatchConfigMapsResponse_FieldTerminalPathArrayOfValues{WatchConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchConfigMapsResponse_FieldPathSelectorSnapshotSize:
		return &WatchConfigMapsResponse_FieldTerminalPathArrayOfValues{WatchConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]int64)}
	case WatchConfigMapsResponse_FieldPathSelectorIsSoftReset:
		return &WatchConfigMapsResponse_FieldTerminalPathArrayOfValues{WatchConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchConfigMapsResponse_FieldPathSelectorIsHardReset:
		return &WatchConfigMapsResponse_FieldTerminalPathArrayOfValues{WatchConfigMapsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *WatchConfigMapsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchConfigMapsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
		return &WatchConfigMapsResponse_FieldTerminalPathArrayItemValue{WatchConfigMapsResponse_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMapChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", fp.selector))
	}
}

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

type WatchConfigMapsResponse_FieldSubPath struct {
	selector WatchConfigMapsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ WatchConfigMapsResponse_FieldPath = (*WatchConfigMapsResponse_FieldSubPath)(nil)

func (fps *WatchConfigMapsResponse_FieldSubPath) Selector() WatchConfigMapsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *WatchConfigMapsResponse_FieldSubPath) AsPageTokenChangeSubPath() (WatchConfigMapsResponsePageTokenChange_FieldPath, bool) {
	res, ok := fps.subPath.(WatchConfigMapsResponsePageTokenChange_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *WatchConfigMapsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*WatchConfigMapsResponse))
}

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

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

func (fps *WatchConfigMapsResponse_FieldSubPath) WithIValue(value interface{}) WatchConfigMapsResponse_FieldPathValue {
	return &WatchConfigMapsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *WatchConfigMapsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) WatchConfigMapsResponse_FieldPathArrayOfValues {
	return &WatchConfigMapsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *WatchConfigMapsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) WatchConfigMapsResponse_FieldPathArrayItemValue {
	return &WatchConfigMapsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseWatchConfigMapsResponse_FieldPathValue(pathStr, valueStr string) WatchConfigMapsResponse_FieldPathValue {
	fpv, err := ParseWatchConfigMapsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConfigMapsResponse_FieldTerminalPathValue struct {
	WatchConfigMapsResponse_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapsResponse_FieldPathValue = (*WatchConfigMapsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchConfigMapsResponse' as interface{}
func (fpv *WatchConfigMapsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchConfigMapsResponse_FieldTerminalPathValue) AsConfigMapChangesValue() ([]*config_map.ConfigMapChange, bool) {
	res, ok := fpv.value.([]*config_map.ConfigMapChange)
	return res, ok
}
func (fpv *WatchConfigMapsResponse_FieldTerminalPathValue) AsIsCurrentValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchConfigMapsResponse_FieldTerminalPathValue) AsPageTokenChangeValue() (*WatchConfigMapsResponse_PageTokenChange, bool) {
	res, ok := fpv.value.(*WatchConfigMapsResponse_PageTokenChange)
	return res, ok
}
func (fpv *WatchConfigMapsResponse_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchConfigMapsResponse_FieldTerminalPathValue) AsSnapshotSizeValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *WatchConfigMapsResponse_FieldTerminalPathValue) AsIsSoftResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchConfigMapsResponse_FieldTerminalPathValue) AsIsHardResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object WatchConfigMapsResponse
func (fpv *WatchConfigMapsResponse_FieldTerminalPathValue) SetTo(target **WatchConfigMapsResponse) {
	if *target == nil {
		*target = new(WatchConfigMapsResponse)
	}
	switch fpv.selector {
	case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
		(*target).ConfigMapChanges = fpv.value.([]*config_map.ConfigMapChange)
	case WatchConfigMapsResponse_FieldPathSelectorIsCurrent:
		(*target).IsCurrent = fpv.value.(bool)
	case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
		(*target).PageTokenChange = fpv.value.(*WatchConfigMapsResponse_PageTokenChange)
	case WatchConfigMapsResponse_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchConfigMapsResponse_FieldPathSelectorSnapshotSize:
		(*target).SnapshotSize = fpv.value.(int64)
	case WatchConfigMapsResponse_FieldPathSelectorIsSoftReset:
		(*target).IsSoftReset = fpv.value.(bool)
	case WatchConfigMapsResponse_FieldPathSelectorIsHardReset:
		(*target).IsHardReset = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", fpv.selector))
	}
}

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

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

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

type WatchConfigMapsResponse_FieldSubPathValue struct {
	WatchConfigMapsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ WatchConfigMapsResponse_FieldPathValue = (*WatchConfigMapsResponse_FieldSubPathValue)(nil)

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

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

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

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

func (fpvs *WatchConfigMapsResponse_FieldSubPathValue) CompareWith(source *WatchConfigMapsResponse) (int, bool) {
	switch fpvs.Selector() {
	case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
		return fpvs.subPathValue.(WatchConfigMapsResponsePageTokenChange_FieldPathValue).CompareWith(source.GetPageTokenChange())
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseWatchConfigMapsResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchConfigMapsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConfigMapsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConfigMapsResponse_FieldTerminalPathArrayItemValue struct {
	WatchConfigMapsResponse_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapsResponse_FieldPathArrayItemValue = (*WatchConfigMapsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchConfigMapsResponse as interface{}
func (fpaiv *WatchConfigMapsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *WatchConfigMapsResponse_FieldTerminalPathArrayItemValue) AsConfigMapChangesItemValue() (*config_map.ConfigMapChange, bool) {
	res, ok := fpaiv.value.(*config_map.ConfigMapChange)
	return res, ok
}

func (fpaiv *WatchConfigMapsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConfigMapsResponse) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'WatchConfigMapsResponse'
func (fpaiv *WatchConfigMapsResponse_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConfigMapsResponse) bool {
	slice := fpaiv.WatchConfigMapsResponse_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 WatchConfigMapsResponse_FieldSubPathArrayItemValue struct {
	WatchConfigMapsResponse_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// WatchConfigMapsResponse_FieldPathArrayOfValues allows storing slice of values for WatchConfigMapsResponse fields according to their type
type WatchConfigMapsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchConfigMapsResponse_FieldPath
}

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

func MustParseWatchConfigMapsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConfigMapsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConfigMapsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConfigMapsResponse_FieldTerminalPathArrayOfValues struct {
	WatchConfigMapsResponse_FieldTerminalPath
	values interface{}
}

var _ WatchConfigMapsResponse_FieldPathArrayOfValues = (*WatchConfigMapsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConfigMapsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConfigMapsResponse_FieldPathSelectorConfigMapChanges:
		for _, v := range fpaov.values.([][]*config_map.ConfigMapChange) {
			values = append(values, v)
		}
	case WatchConfigMapsResponse_FieldPathSelectorIsCurrent:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchConfigMapsResponse_FieldPathSelectorPageTokenChange:
		for _, v := range fpaov.values.([]*WatchConfigMapsResponse_PageTokenChange) {
			values = append(values, v)
		}
	case WatchConfigMapsResponse_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchConfigMapsResponse_FieldPathSelectorSnapshotSize:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case WatchConfigMapsResponse_FieldPathSelectorIsSoftReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchConfigMapsResponse_FieldPathSelectorIsHardReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConfigMapsResponse_FieldTerminalPathArrayOfValues) AsConfigMapChangesArrayOfValues() ([][]*config_map.ConfigMapChange, bool) {
	res, ok := fpaov.values.([][]*config_map.ConfigMapChange)
	return res, ok
}
func (fpaov *WatchConfigMapsResponse_FieldTerminalPathArrayOfValues) AsIsCurrentArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchConfigMapsResponse_FieldTerminalPathArrayOfValues) AsPageTokenChangeArrayOfValues() ([]*WatchConfigMapsResponse_PageTokenChange, bool) {
	res, ok := fpaov.values.([]*WatchConfigMapsResponse_PageTokenChange)
	return res, ok
}
func (fpaov *WatchConfigMapsResponse_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchConfigMapsResponse_FieldTerminalPathArrayOfValues) AsSnapshotSizeArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *WatchConfigMapsResponse_FieldTerminalPathArrayOfValues) AsIsSoftResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchConfigMapsResponse_FieldTerminalPathArrayOfValues) AsIsHardResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type WatchConfigMapsResponse_FieldSubPathArrayOfValues struct {
	WatchConfigMapsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ WatchConfigMapsResponse_FieldPathArrayOfValues = (*WatchConfigMapsResponse_FieldSubPathArrayOfValues)(nil)

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

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

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

type WatchConfigMapsResponsePageTokenChange_FieldPathSelector int32

const (
	WatchConfigMapsResponsePageTokenChange_FieldPathSelectorPrevPageToken WatchConfigMapsResponsePageTokenChange_FieldPathSelector = 0
	WatchConfigMapsResponsePageTokenChange_FieldPathSelectorNextPageToken WatchConfigMapsResponsePageTokenChange_FieldPathSelector = 1
)

func (s WatchConfigMapsResponsePageTokenChange_FieldPathSelector) String() string {
	switch s {
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return "next_page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse_PageTokenChange: %d", s))
	}
}

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

func ParseWatchConfigMapsResponsePageTokenChange_FieldPath(rawField string) (WatchConfigMapsResponsePageTokenChange_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchConfigMapsResponsePageTokenChange_FieldPath(fp)
}

func MustParseWatchConfigMapsResponsePageTokenChange_FieldPath(rawField string) WatchConfigMapsResponsePageTokenChange_FieldPath {
	fp, err := ParseWatchConfigMapsResponsePageTokenChange_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchConfigMapsResponsePageTokenChange_FieldTerminalPath struct {
	selector WatchConfigMapsResponsePageTokenChange_FieldPathSelector
}

var _ WatchConfigMapsResponsePageTokenChange_FieldPath = (*WatchConfigMapsResponsePageTokenChange_FieldTerminalPath)(nil)

func (fp *WatchConfigMapsResponsePageTokenChange_FieldTerminalPath) Selector() WatchConfigMapsResponsePageTokenChange_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchConfigMapsResponsePageTokenChange_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return (*config_map.PagerCursor)(nil)
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return (*config_map.PagerCursor)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchConfigMapsResponsePageTokenChange_FieldTerminalPath) ClearValue(item *WatchConfigMapsResponse_PageTokenChange) {
	if item != nil {
		switch fp.selector {
		case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse_PageTokenChange: %d", fp.selector))
		}
	}
}

func (fp *WatchConfigMapsResponsePageTokenChange_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchConfigMapsResponse_PageTokenChange))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchConfigMapsResponsePageTokenChange_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchConfigMapsResponsePageTokenChange_FieldPathSelectorPrevPageToken ||
		fp.selector == WatchConfigMapsResponsePageTokenChange_FieldPathSelectorNextPageToken
}

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

func (fp *WatchConfigMapsResponsePageTokenChange_FieldTerminalPath) WithIValue(value interface{}) WatchConfigMapsResponsePageTokenChange_FieldPathValue {
	switch fp.selector {
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchConfigMapsResponsePageTokenChange_FieldTerminalPathValue{WatchConfigMapsResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*config_map.PagerCursor)}
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchConfigMapsResponsePageTokenChange_FieldTerminalPathValue{WatchConfigMapsResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*config_map.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse_PageTokenChange: %d", fp.selector))
	}
}

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

func (fp *WatchConfigMapsResponsePageTokenChange_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchConfigMapsResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov := &WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchConfigMapsResponsePageTokenChange_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchConfigMapsResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*config_map.PagerCursor)}
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchConfigMapsResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*config_map.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse_PageTokenChange: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchConfigMapsResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) WatchConfigMapsResponsePageTokenChange_FieldPathValue {
	fpv, err := ParseWatchConfigMapsResponsePageTokenChange_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchConfigMapsResponsePageTokenChange_FieldTerminalPathValue struct {
	WatchConfigMapsResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapsResponsePageTokenChange_FieldPathValue = (*WatchConfigMapsResponsePageTokenChange_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object PageTokenChange
func (fpv *WatchConfigMapsResponsePageTokenChange_FieldTerminalPathValue) SetTo(target **WatchConfigMapsResponse_PageTokenChange) {
	if *target == nil {
		*target = new(WatchConfigMapsResponse_PageTokenChange)
	}
	switch fpv.selector {
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*config_map.PagerCursor)
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*config_map.PagerCursor)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchConfigMapsResponse_PageTokenChange: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseWatchConfigMapsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) WatchConfigMapsResponsePageTokenChange_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchConfigMapsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayItemValue struct {
	WatchConfigMapsResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchConfigMapsResponsePageTokenChange_FieldPathArrayItemValue = (*WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayItemValue) GetSingle(source *WatchConfigMapsResponse_PageTokenChange) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'PageTokenChange'
func (fpaiv *WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayItemValue) ContainsValue(source *WatchConfigMapsResponse_PageTokenChange) bool {
	slice := fpaiv.WatchConfigMapsResponsePageTokenChange_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
}

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

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

func MustParseWatchConfigMapsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) WatchConfigMapsResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov, err := ParseWatchConfigMapsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayOfValues struct {
	WatchConfigMapsResponsePageTokenChange_FieldTerminalPath
	values interface{}
}

var _ WatchConfigMapsResponsePageTokenChange_FieldPathArrayOfValues = (*WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*config_map.PagerCursor) {
			values = append(values, v)
		}
	case WatchConfigMapsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*config_map.PagerCursor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*config_map.PagerCursor, bool) {
	res, ok := fpaov.values.([]*config_map.PagerCursor)
	return res, ok
}
func (fpaov *WatchConfigMapsResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*config_map.PagerCursor, bool) {
	res, ok := fpaov.values.([]*config_map.PagerCursor)
	return res, ok
}

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

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

type CreateConfigMapRequest_FieldPathSelector int32

const (
	CreateConfigMapRequest_FieldPathSelectorParent    CreateConfigMapRequest_FieldPathSelector = 0
	CreateConfigMapRequest_FieldPathSelectorConfigMap CreateConfigMapRequest_FieldPathSelector = 1
)

func (s CreateConfigMapRequest_FieldPathSelector) String() string {
	switch s {
	case CreateConfigMapRequest_FieldPathSelectorParent:
		return "parent"
	case CreateConfigMapRequest_FieldPathSelectorConfigMap:
		return "config_map"
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", s))
	}
}

func BuildCreateConfigMapRequest_FieldPath(fp gotenobject.RawFieldPath) (CreateConfigMapRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreateConfigMapRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &CreateConfigMapRequest_FieldTerminalPath{selector: CreateConfigMapRequest_FieldPathSelectorParent}, nil
		case "config_map", "configMap", "config-map":
			return &CreateConfigMapRequest_FieldTerminalPath{selector: CreateConfigMapRequest_FieldPathSelectorConfigMap}, nil
		}
	} else {
		switch fp[0] {
		case "config_map", "configMap", "config-map":
			if subpath, err := config_map.BuildConfigMap_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateConfigMapRequest_FieldSubPath{selector: CreateConfigMapRequest_FieldPathSelectorConfigMap, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreateConfigMapRequest", fp)
}

func ParseCreateConfigMapRequest_FieldPath(rawField string) (CreateConfigMapRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreateConfigMapRequest_FieldPath(fp)
}

func MustParseCreateConfigMapRequest_FieldPath(rawField string) CreateConfigMapRequest_FieldPath {
	fp, err := ParseCreateConfigMapRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreateConfigMapRequest_FieldTerminalPath struct {
	selector CreateConfigMapRequest_FieldPathSelector
}

var _ CreateConfigMapRequest_FieldPath = (*CreateConfigMapRequest_FieldTerminalPath)(nil)

func (fp *CreateConfigMapRequest_FieldTerminalPath) Selector() CreateConfigMapRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *CreateConfigMapRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreateConfigMapRequest_FieldPathSelectorParent:
		return (*config_map.ParentReference)(nil)
	case CreateConfigMapRequest_FieldPathSelectorConfigMap:
		return (*config_map.ConfigMap)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", fp.selector))
	}
}

func (fp *CreateConfigMapRequest_FieldTerminalPath) ClearValue(item *CreateConfigMapRequest) {
	if item != nil {
		switch fp.selector {
		case CreateConfigMapRequest_FieldPathSelectorParent:
			item.Parent = nil
		case CreateConfigMapRequest_FieldPathSelectorConfigMap:
			item.ConfigMap = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", fp.selector))
		}
	}
}

func (fp *CreateConfigMapRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreateConfigMapRequest))
}

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

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

func (fp *CreateConfigMapRequest_FieldTerminalPath) WithIValue(value interface{}) CreateConfigMapRequest_FieldPathValue {
	switch fp.selector {
	case CreateConfigMapRequest_FieldPathSelectorParent:
		return &CreateConfigMapRequest_FieldTerminalPathValue{CreateConfigMapRequest_FieldTerminalPath: *fp, value: value.(*config_map.ParentReference)}
	case CreateConfigMapRequest_FieldPathSelectorConfigMap:
		return &CreateConfigMapRequest_FieldTerminalPathValue{CreateConfigMapRequest_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", fp.selector))
	}
}

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

func (fp *CreateConfigMapRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreateConfigMapRequest_FieldPathArrayOfValues {
	fpaov := &CreateConfigMapRequest_FieldTerminalPathArrayOfValues{CreateConfigMapRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreateConfigMapRequest_FieldPathSelectorParent:
		return &CreateConfigMapRequest_FieldTerminalPathArrayOfValues{CreateConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ParentReference)}
	case CreateConfigMapRequest_FieldPathSelectorConfigMap:
		return &CreateConfigMapRequest_FieldTerminalPathArrayOfValues{CreateConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type CreateConfigMapRequest_FieldSubPath struct {
	selector CreateConfigMapRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreateConfigMapRequest_FieldPath = (*CreateConfigMapRequest_FieldSubPath)(nil)

func (fps *CreateConfigMapRequest_FieldSubPath) Selector() CreateConfigMapRequest_FieldPathSelector {
	return fps.selector
}
func (fps *CreateConfigMapRequest_FieldSubPath) AsConfigMapSubPath() (config_map.ConfigMap_FieldPath, bool) {
	res, ok := fps.subPath.(config_map.ConfigMap_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *CreateConfigMapRequest_FieldSubPath) ClearValue(item *CreateConfigMapRequest) {
	if item != nil {
		switch fps.selector {
		case CreateConfigMapRequest_FieldPathSelectorConfigMap:
			fps.subPath.ClearValueRaw(item.ConfigMap)
		default:
			panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", fps.selector))
		}
	}
}

func (fps *CreateConfigMapRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreateConfigMapRequest))
}

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

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

func (fps *CreateConfigMapRequest_FieldSubPath) WithIValue(value interface{}) CreateConfigMapRequest_FieldPathValue {
	return &CreateConfigMapRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *CreateConfigMapRequest_FieldSubPath) WithIArrayOfValues(values interface{}) CreateConfigMapRequest_FieldPathArrayOfValues {
	return &CreateConfigMapRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *CreateConfigMapRequest_FieldSubPath) WithIArrayItemValue(value interface{}) CreateConfigMapRequest_FieldPathArrayItemValue {
	return &CreateConfigMapRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseCreateConfigMapRequest_FieldPathValue(pathStr, valueStr string) CreateConfigMapRequest_FieldPathValue {
	fpv, err := ParseCreateConfigMapRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreateConfigMapRequest_FieldTerminalPathValue struct {
	CreateConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ CreateConfigMapRequest_FieldPathValue = (*CreateConfigMapRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreateConfigMapRequest' as interface{}
func (fpv *CreateConfigMapRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreateConfigMapRequest_FieldTerminalPathValue) AsParentValue() (*config_map.ParentReference, bool) {
	res, ok := fpv.value.(*config_map.ParentReference)
	return res, ok
}
func (fpv *CreateConfigMapRequest_FieldTerminalPathValue) AsConfigMapValue() (*config_map.ConfigMap, bool) {
	res, ok := fpv.value.(*config_map.ConfigMap)
	return res, ok
}

// SetTo stores value for selected field for object CreateConfigMapRequest
func (fpv *CreateConfigMapRequest_FieldTerminalPathValue) SetTo(target **CreateConfigMapRequest) {
	if *target == nil {
		*target = new(CreateConfigMapRequest)
	}
	switch fpv.selector {
	case CreateConfigMapRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*config_map.ParentReference)
	case CreateConfigMapRequest_FieldPathSelectorConfigMap:
		(*target).ConfigMap = fpv.value.(*config_map.ConfigMap)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'CreateConfigMapRequest_FieldTerminalPathValue' with the value under path in 'CreateConfigMapRequest'.
func (fpv *CreateConfigMapRequest_FieldTerminalPathValue) CompareWith(source *CreateConfigMapRequest) (int, bool) {
	switch fpv.selector {
	case CreateConfigMapRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*config_map.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 CreateConfigMapRequest_FieldPathSelectorConfigMap:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", fpv.selector))
	}
}

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

type CreateConfigMapRequest_FieldSubPathValue struct {
	CreateConfigMapRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreateConfigMapRequest_FieldPathValue = (*CreateConfigMapRequest_FieldSubPathValue)(nil)

func (fpvs *CreateConfigMapRequest_FieldSubPathValue) AsConfigMapPathValue() (config_map.ConfigMap_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue)
	return res, ok
}

func (fpvs *CreateConfigMapRequest_FieldSubPathValue) SetTo(target **CreateConfigMapRequest) {
	if *target == nil {
		*target = new(CreateConfigMapRequest)
	}
	switch fpvs.Selector() {
	case CreateConfigMapRequest_FieldPathSelectorConfigMap:
		fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue).SetTo(&(*target).ConfigMap)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *CreateConfigMapRequest_FieldSubPathValue) CompareWith(source *CreateConfigMapRequest) (int, bool) {
	switch fpvs.Selector() {
	case CreateConfigMapRequest_FieldPathSelectorConfigMap:
		return fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue).CompareWith(source.GetConfigMap())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateConfigMapRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseCreateConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr string) CreateConfigMapRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseCreateConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreateConfigMapRequest_FieldTerminalPathArrayItemValue struct {
	CreateConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ CreateConfigMapRequest_FieldPathArrayItemValue = (*CreateConfigMapRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *CreateConfigMapRequest_FieldTerminalPathArrayItemValue) GetSingle(source *CreateConfigMapRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'CreateConfigMapRequest'
func (fpaiv *CreateConfigMapRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *CreateConfigMapRequest) bool {
	slice := fpaiv.CreateConfigMapRequest_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 CreateConfigMapRequest_FieldSubPathArrayItemValue struct {
	CreateConfigMapRequest_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *CreateConfigMapRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *CreateConfigMapRequest_FieldSubPathArrayItemValue) AsConfigMapPathItemValue() (config_map.ConfigMap_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(config_map.ConfigMap_FieldPathArrayItemValue)
	return res, ok
}

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

// CreateConfigMapRequest_FieldPathArrayOfValues allows storing slice of values for CreateConfigMapRequest fields according to their type
type CreateConfigMapRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreateConfigMapRequest_FieldPath
}

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

func MustParseCreateConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr string) CreateConfigMapRequest_FieldPathArrayOfValues {
	fpaov, err := ParseCreateConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreateConfigMapRequest_FieldTerminalPathArrayOfValues struct {
	CreateConfigMapRequest_FieldTerminalPath
	values interface{}
}

var _ CreateConfigMapRequest_FieldPathArrayOfValues = (*CreateConfigMapRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreateConfigMapRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreateConfigMapRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*config_map.ParentReference) {
			values = append(values, v)
		}
	case CreateConfigMapRequest_FieldPathSelectorConfigMap:
		for _, v := range fpaov.values.([]*config_map.ConfigMap) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreateConfigMapRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*config_map.ParentReference, bool) {
	res, ok := fpaov.values.([]*config_map.ParentReference)
	return res, ok
}
func (fpaov *CreateConfigMapRequest_FieldTerminalPathArrayOfValues) AsConfigMapArrayOfValues() ([]*config_map.ConfigMap, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap)
	return res, ok
}

type CreateConfigMapRequest_FieldSubPathArrayOfValues struct {
	CreateConfigMapRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreateConfigMapRequest_FieldPathArrayOfValues = (*CreateConfigMapRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *CreateConfigMapRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *CreateConfigMapRequest_FieldSubPathArrayOfValues) AsConfigMapPathArrayOfValues() (config_map.ConfigMap_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(config_map.ConfigMap_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateConfigMapRequest_FieldPathSelector int32

const (
	UpdateConfigMapRequest_FieldPathSelectorConfigMap  UpdateConfigMapRequest_FieldPathSelector = 0
	UpdateConfigMapRequest_FieldPathSelectorUpdateMask UpdateConfigMapRequest_FieldPathSelector = 1
	UpdateConfigMapRequest_FieldPathSelectorCas        UpdateConfigMapRequest_FieldPathSelector = 2
)

func (s UpdateConfigMapRequest_FieldPathSelector) String() string {
	switch s {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		return "config_map"
	case UpdateConfigMapRequest_FieldPathSelectorUpdateMask:
		return "update_mask"
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		return "cas"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", s))
	}
}

func BuildUpdateConfigMapRequest_FieldPath(fp gotenobject.RawFieldPath) (UpdateConfigMapRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateConfigMapRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "config_map", "configMap", "config-map":
			return &UpdateConfigMapRequest_FieldTerminalPath{selector: UpdateConfigMapRequest_FieldPathSelectorConfigMap}, nil
		case "update_mask", "updateMask", "update-mask":
			return &UpdateConfigMapRequest_FieldTerminalPath{selector: UpdateConfigMapRequest_FieldPathSelectorUpdateMask}, nil
		case "cas":
			return &UpdateConfigMapRequest_FieldTerminalPath{selector: UpdateConfigMapRequest_FieldPathSelectorCas}, nil
		}
	} else {
		switch fp[0] {
		case "config_map", "configMap", "config-map":
			if subpath, err := config_map.BuildConfigMap_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateConfigMapRequest_FieldSubPath{selector: UpdateConfigMapRequest_FieldPathSelectorConfigMap, subPath: subpath}, nil
			}
		case "cas":
			if subpath, err := BuildUpdateConfigMapRequestCAS_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateConfigMapRequest_FieldSubPath{selector: UpdateConfigMapRequest_FieldPathSelectorCas, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateConfigMapRequest", fp)
}

func ParseUpdateConfigMapRequest_FieldPath(rawField string) (UpdateConfigMapRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateConfigMapRequest_FieldPath(fp)
}

func MustParseUpdateConfigMapRequest_FieldPath(rawField string) UpdateConfigMapRequest_FieldPath {
	fp, err := ParseUpdateConfigMapRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateConfigMapRequest_FieldTerminalPath struct {
	selector UpdateConfigMapRequest_FieldPathSelector
}

var _ UpdateConfigMapRequest_FieldPath = (*UpdateConfigMapRequest_FieldTerminalPath)(nil)

func (fp *UpdateConfigMapRequest_FieldTerminalPath) Selector() UpdateConfigMapRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source UpdateConfigMapRequest
func (fp *UpdateConfigMapRequest_FieldTerminalPath) Get(source *UpdateConfigMapRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
			if source.ConfigMap != nil {
				values = append(values, source.ConfigMap)
			}
		case UpdateConfigMapRequest_FieldPathSelectorUpdateMask:
			if source.UpdateMask != nil {
				values = append(values, source.UpdateMask)
			}
		case UpdateConfigMapRequest_FieldPathSelectorCas:
			if source.Cas != nil {
				values = append(values, source.Cas)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source UpdateConfigMapRequest
func (fp *UpdateConfigMapRequest_FieldTerminalPath) GetSingle(source *UpdateConfigMapRequest) (interface{}, bool) {
	switch fp.selector {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		res := source.GetConfigMap()
		return res, res != nil
	case UpdateConfigMapRequest_FieldPathSelectorUpdateMask:
		res := source.GetUpdateMask()
		return res, res != nil
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		res := source.GetCas()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *UpdateConfigMapRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		return (*config_map.ConfigMap)(nil)
	case UpdateConfigMapRequest_FieldPathSelectorUpdateMask:
		return (*config_map.ConfigMap_FieldMask)(nil)
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		return (*UpdateConfigMapRequest_CAS)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fp.selector))
	}
}

func (fp *UpdateConfigMapRequest_FieldTerminalPath) ClearValue(item *UpdateConfigMapRequest) {
	if item != nil {
		switch fp.selector {
		case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
			item.ConfigMap = nil
		case UpdateConfigMapRequest_FieldPathSelectorUpdateMask:
			item.UpdateMask = nil
		case UpdateConfigMapRequest_FieldPathSelectorCas:
			item.Cas = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fp.selector))
		}
	}
}

func (fp *UpdateConfigMapRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateConfigMapRequest))
}

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

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

func (fp *UpdateConfigMapRequest_FieldTerminalPath) WithIValue(value interface{}) UpdateConfigMapRequest_FieldPathValue {
	switch fp.selector {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		return &UpdateConfigMapRequest_FieldTerminalPathValue{UpdateConfigMapRequest_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap)}
	case UpdateConfigMapRequest_FieldPathSelectorUpdateMask:
		return &UpdateConfigMapRequest_FieldTerminalPathValue{UpdateConfigMapRequest_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap_FieldMask)}
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		return &UpdateConfigMapRequest_FieldTerminalPathValue{UpdateConfigMapRequest_FieldTerminalPath: *fp, value: value.(*UpdateConfigMapRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fp.selector))
	}
}

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

func (fp *UpdateConfigMapRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateConfigMapRequest_FieldPathArrayOfValues {
	fpaov := &UpdateConfigMapRequest_FieldTerminalPathArrayOfValues{UpdateConfigMapRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		return &UpdateConfigMapRequest_FieldTerminalPathArrayOfValues{UpdateConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap)}
	case UpdateConfigMapRequest_FieldPathSelectorUpdateMask:
		return &UpdateConfigMapRequest_FieldTerminalPathArrayOfValues{UpdateConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap_FieldMask)}
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		return &UpdateConfigMapRequest_FieldTerminalPathArrayOfValues{UpdateConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*UpdateConfigMapRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateConfigMapRequest_FieldSubPath struct {
	selector UpdateConfigMapRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateConfigMapRequest_FieldPath = (*UpdateConfigMapRequest_FieldSubPath)(nil)

func (fps *UpdateConfigMapRequest_FieldSubPath) Selector() UpdateConfigMapRequest_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateConfigMapRequest_FieldSubPath) AsConfigMapSubPath() (config_map.ConfigMap_FieldPath, bool) {
	res, ok := fps.subPath.(config_map.ConfigMap_FieldPath)
	return res, ok
}
func (fps *UpdateConfigMapRequest_FieldSubPath) AsCasSubPath() (UpdateConfigMapRequestCAS_FieldPath, bool) {
	res, ok := fps.subPath.(UpdateConfigMapRequestCAS_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *UpdateConfigMapRequest_FieldSubPath) ClearValue(item *UpdateConfigMapRequest) {
	if item != nil {
		switch fps.selector {
		case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
			fps.subPath.ClearValueRaw(item.ConfigMap)
		case UpdateConfigMapRequest_FieldPathSelectorCas:
			fps.subPath.ClearValueRaw(item.Cas)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fps.selector))
		}
	}
}

func (fps *UpdateConfigMapRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateConfigMapRequest))
}

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

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

func (fps *UpdateConfigMapRequest_FieldSubPath) WithIValue(value interface{}) UpdateConfigMapRequest_FieldPathValue {
	return &UpdateConfigMapRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateConfigMapRequest_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateConfigMapRequest_FieldPathArrayOfValues {
	return &UpdateConfigMapRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateConfigMapRequest_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateConfigMapRequest_FieldPathArrayItemValue {
	return &UpdateConfigMapRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseUpdateConfigMapRequest_FieldPathValue(pathStr, valueStr string) UpdateConfigMapRequest_FieldPathValue {
	fpv, err := ParseUpdateConfigMapRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateConfigMapRequest_FieldTerminalPathValue struct {
	UpdateConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateConfigMapRequest_FieldPathValue = (*UpdateConfigMapRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'UpdateConfigMapRequest' as interface{}
func (fpv *UpdateConfigMapRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateConfigMapRequest_FieldTerminalPathValue) AsConfigMapValue() (*config_map.ConfigMap, bool) {
	res, ok := fpv.value.(*config_map.ConfigMap)
	return res, ok
}
func (fpv *UpdateConfigMapRequest_FieldTerminalPathValue) AsUpdateMaskValue() (*config_map.ConfigMap_FieldMask, bool) {
	res, ok := fpv.value.(*config_map.ConfigMap_FieldMask)
	return res, ok
}
func (fpv *UpdateConfigMapRequest_FieldTerminalPathValue) AsCasValue() (*UpdateConfigMapRequest_CAS, bool) {
	res, ok := fpv.value.(*UpdateConfigMapRequest_CAS)
	return res, ok
}

// SetTo stores value for selected field for object UpdateConfigMapRequest
func (fpv *UpdateConfigMapRequest_FieldTerminalPathValue) SetTo(target **UpdateConfigMapRequest) {
	if *target == nil {
		*target = new(UpdateConfigMapRequest)
	}
	switch fpv.selector {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		(*target).ConfigMap = fpv.value.(*config_map.ConfigMap)
	case UpdateConfigMapRequest_FieldPathSelectorUpdateMask:
		(*target).UpdateMask = fpv.value.(*config_map.ConfigMap_FieldMask)
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		(*target).Cas = fpv.value.(*UpdateConfigMapRequest_CAS)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fpv.selector))
	}
}

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

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

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

type UpdateConfigMapRequest_FieldSubPathValue struct {
	UpdateConfigMapRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateConfigMapRequest_FieldPathValue = (*UpdateConfigMapRequest_FieldSubPathValue)(nil)

func (fpvs *UpdateConfigMapRequest_FieldSubPathValue) AsConfigMapPathValue() (config_map.ConfigMap_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue)
	return res, ok
}
func (fpvs *UpdateConfigMapRequest_FieldSubPathValue) AsCasPathValue() (UpdateConfigMapRequestCAS_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(UpdateConfigMapRequestCAS_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateConfigMapRequest_FieldSubPathValue) SetTo(target **UpdateConfigMapRequest) {
	if *target == nil {
		*target = new(UpdateConfigMapRequest)
	}
	switch fpvs.Selector() {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue).SetTo(&(*target).ConfigMap)
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		fpvs.subPathValue.(UpdateConfigMapRequestCAS_FieldPathValue).SetTo(&(*target).Cas)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateConfigMapRequest_FieldSubPathValue) CompareWith(source *UpdateConfigMapRequest) (int, bool) {
	switch fpvs.Selector() {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		return fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue).CompareWith(source.GetConfigMap())
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		return fpvs.subPathValue.(UpdateConfigMapRequestCAS_FieldPathValue).CompareWith(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseUpdateConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr string) UpdateConfigMapRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateConfigMapRequest_FieldTerminalPathArrayItemValue struct {
	UpdateConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateConfigMapRequest_FieldPathArrayItemValue = (*UpdateConfigMapRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateConfigMapRequest_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateConfigMapRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'UpdateConfigMapRequest'
func (fpaiv *UpdateConfigMapRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *UpdateConfigMapRequest) bool {
	slice := fpaiv.UpdateConfigMapRequest_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 UpdateConfigMapRequest_FieldSubPathArrayItemValue struct {
	UpdateConfigMapRequest_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *UpdateConfigMapRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdateConfigMapRequest_FieldSubPathArrayItemValue) AsConfigMapPathItemValue() (config_map.ConfigMap_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(config_map.ConfigMap_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *UpdateConfigMapRequest_FieldSubPathArrayItemValue) AsCasPathItemValue() (UpdateConfigMapRequestCAS_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(UpdateConfigMapRequestCAS_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'UpdateConfigMapRequest'
func (fpaivs *UpdateConfigMapRequest_FieldSubPathArrayItemValue) ContainsValue(source *UpdateConfigMapRequest) bool {
	switch fpaivs.Selector() {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		return fpaivs.subPathItemValue.(config_map.ConfigMap_FieldPathArrayItemValue).ContainsValue(source.GetConfigMap())
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		return fpaivs.subPathItemValue.(UpdateConfigMapRequestCAS_FieldPathArrayItemValue).ContainsValue(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest: %d", fpaivs.Selector()))
	}
}

// UpdateConfigMapRequest_FieldPathArrayOfValues allows storing slice of values for UpdateConfigMapRequest fields according to their type
type UpdateConfigMapRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdateConfigMapRequest_FieldPath
}

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

func MustParseUpdateConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateConfigMapRequest_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateConfigMapRequest_FieldTerminalPathArrayOfValues struct {
	UpdateConfigMapRequest_FieldTerminalPath
	values interface{}
}

var _ UpdateConfigMapRequest_FieldPathArrayOfValues = (*UpdateConfigMapRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateConfigMapRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateConfigMapRequest_FieldPathSelectorConfigMap:
		for _, v := range fpaov.values.([]*config_map.ConfigMap) {
			values = append(values, v)
		}
	case UpdateConfigMapRequest_FieldPathSelectorUpdateMask:
		for _, v := range fpaov.values.([]*config_map.ConfigMap_FieldMask) {
			values = append(values, v)
		}
	case UpdateConfigMapRequest_FieldPathSelectorCas:
		for _, v := range fpaov.values.([]*UpdateConfigMapRequest_CAS) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateConfigMapRequest_FieldTerminalPathArrayOfValues) AsConfigMapArrayOfValues() ([]*config_map.ConfigMap, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap)
	return res, ok
}
func (fpaov *UpdateConfigMapRequest_FieldTerminalPathArrayOfValues) AsUpdateMaskArrayOfValues() ([]*config_map.ConfigMap_FieldMask, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap_FieldMask)
	return res, ok
}
func (fpaov *UpdateConfigMapRequest_FieldTerminalPathArrayOfValues) AsCasArrayOfValues() ([]*UpdateConfigMapRequest_CAS, bool) {
	res, ok := fpaov.values.([]*UpdateConfigMapRequest_CAS)
	return res, ok
}

type UpdateConfigMapRequest_FieldSubPathArrayOfValues struct {
	UpdateConfigMapRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateConfigMapRequest_FieldPathArrayOfValues = (*UpdateConfigMapRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateConfigMapRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateConfigMapRequest_FieldSubPathArrayOfValues) AsConfigMapPathArrayOfValues() (config_map.ConfigMap_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(config_map.ConfigMap_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *UpdateConfigMapRequest_FieldSubPathArrayOfValues) AsCasPathArrayOfValues() (UpdateConfigMapRequestCAS_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(UpdateConfigMapRequestCAS_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateConfigMapRequestCAS_FieldPathSelector int32

const (
	UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState UpdateConfigMapRequestCAS_FieldPathSelector = 0
	UpdateConfigMapRequestCAS_FieldPathSelectorFieldMask        UpdateConfigMapRequestCAS_FieldPathSelector = 1
)

func (s UpdateConfigMapRequestCAS_FieldPathSelector) String() string {
	switch s {
	case UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState:
		return "conditional_state"
	case UpdateConfigMapRequestCAS_FieldPathSelectorFieldMask:
		return "field_mask"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest_CAS: %d", s))
	}
}

func BuildUpdateConfigMapRequestCAS_FieldPath(fp gotenobject.RawFieldPath) (UpdateConfigMapRequestCAS_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateConfigMapRequest_CAS")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			return &UpdateConfigMapRequestCAS_FieldTerminalPath{selector: UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &UpdateConfigMapRequestCAS_FieldTerminalPath{selector: UpdateConfigMapRequestCAS_FieldPathSelectorFieldMask}, nil
		}
	} else {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			if subpath, err := config_map.BuildConfigMap_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateConfigMapRequestCAS_FieldSubPath{selector: UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateConfigMapRequest_CAS", fp)
}

func ParseUpdateConfigMapRequestCAS_FieldPath(rawField string) (UpdateConfigMapRequestCAS_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateConfigMapRequestCAS_FieldPath(fp)
}

func MustParseUpdateConfigMapRequestCAS_FieldPath(rawField string) UpdateConfigMapRequestCAS_FieldPath {
	fp, err := ParseUpdateConfigMapRequestCAS_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateConfigMapRequestCAS_FieldTerminalPath struct {
	selector UpdateConfigMapRequestCAS_FieldPathSelector
}

var _ UpdateConfigMapRequestCAS_FieldPath = (*UpdateConfigMapRequestCAS_FieldTerminalPath)(nil)

func (fp *UpdateConfigMapRequestCAS_FieldTerminalPath) Selector() UpdateConfigMapRequestCAS_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *UpdateConfigMapRequestCAS_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState:
		return (*config_map.ConfigMap)(nil)
	case UpdateConfigMapRequestCAS_FieldPathSelectorFieldMask:
		return (*config_map.ConfigMap_FieldMask)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdateConfigMapRequestCAS_FieldTerminalPath) ClearValue(item *UpdateConfigMapRequest_CAS) {
	if item != nil {
		switch fp.selector {
		case UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState:
			item.ConditionalState = nil
		case UpdateConfigMapRequestCAS_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest_CAS: %d", fp.selector))
		}
	}
}

func (fp *UpdateConfigMapRequestCAS_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateConfigMapRequest_CAS))
}

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

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

func (fp *UpdateConfigMapRequestCAS_FieldTerminalPath) WithIValue(value interface{}) UpdateConfigMapRequestCAS_FieldPathValue {
	switch fp.selector {
	case UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateConfigMapRequestCAS_FieldTerminalPathValue{UpdateConfigMapRequestCAS_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap)}
	case UpdateConfigMapRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateConfigMapRequestCAS_FieldTerminalPathValue{UpdateConfigMapRequestCAS_FieldTerminalPath: *fp, value: value.(*config_map.ConfigMap_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest_CAS: %d", fp.selector))
	}
}

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

func (fp *UpdateConfigMapRequestCAS_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateConfigMapRequestCAS_FieldPathArrayOfValues {
	fpaov := &UpdateConfigMapRequestCAS_FieldTerminalPathArrayOfValues{UpdateConfigMapRequestCAS_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateConfigMapRequestCAS_FieldTerminalPathArrayOfValues{UpdateConfigMapRequestCAS_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap)}
	case UpdateConfigMapRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateConfigMapRequestCAS_FieldTerminalPathArrayOfValues{UpdateConfigMapRequestCAS_FieldTerminalPath: *fp, values: values.([]*config_map.ConfigMap_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest_CAS: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateConfigMapRequestCAS_FieldSubPath struct {
	selector UpdateConfigMapRequestCAS_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateConfigMapRequestCAS_FieldPath = (*UpdateConfigMapRequestCAS_FieldSubPath)(nil)

func (fps *UpdateConfigMapRequestCAS_FieldSubPath) Selector() UpdateConfigMapRequestCAS_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateConfigMapRequestCAS_FieldSubPath) AsConditionalStateSubPath() (config_map.ConfigMap_FieldPath, bool) {
	res, ok := fps.subPath.(config_map.ConfigMap_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *UpdateConfigMapRequestCAS_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateConfigMapRequest_CAS))
}

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

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

func (fps *UpdateConfigMapRequestCAS_FieldSubPath) WithIValue(value interface{}) UpdateConfigMapRequestCAS_FieldPathValue {
	return &UpdateConfigMapRequestCAS_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateConfigMapRequestCAS_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateConfigMapRequestCAS_FieldPathArrayOfValues {
	return &UpdateConfigMapRequestCAS_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateConfigMapRequestCAS_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateConfigMapRequestCAS_FieldPathArrayItemValue {
	return &UpdateConfigMapRequestCAS_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseUpdateConfigMapRequestCAS_FieldPathValue(pathStr, valueStr string) UpdateConfigMapRequestCAS_FieldPathValue {
	fpv, err := ParseUpdateConfigMapRequestCAS_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateConfigMapRequestCAS_FieldTerminalPathValue struct {
	UpdateConfigMapRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateConfigMapRequestCAS_FieldPathValue = (*UpdateConfigMapRequestCAS_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CAS' as interface{}
func (fpv *UpdateConfigMapRequestCAS_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateConfigMapRequestCAS_FieldTerminalPathValue) AsConditionalStateValue() (*config_map.ConfigMap, bool) {
	res, ok := fpv.value.(*config_map.ConfigMap)
	return res, ok
}
func (fpv *UpdateConfigMapRequestCAS_FieldTerminalPathValue) AsFieldMaskValue() (*config_map.ConfigMap_FieldMask, bool) {
	res, ok := fpv.value.(*config_map.ConfigMap_FieldMask)
	return res, ok
}

// SetTo stores value for selected field for object CAS
func (fpv *UpdateConfigMapRequestCAS_FieldTerminalPathValue) SetTo(target **UpdateConfigMapRequest_CAS) {
	if *target == nil {
		*target = new(UpdateConfigMapRequest_CAS)
	}
	switch fpv.selector {
	case UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState:
		(*target).ConditionalState = fpv.value.(*config_map.ConfigMap)
	case UpdateConfigMapRequestCAS_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*config_map.ConfigMap_FieldMask)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest_CAS: %d", fpv.selector))
	}
}

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

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

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

type UpdateConfigMapRequestCAS_FieldSubPathValue struct {
	UpdateConfigMapRequestCAS_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateConfigMapRequestCAS_FieldPathValue = (*UpdateConfigMapRequestCAS_FieldSubPathValue)(nil)

func (fpvs *UpdateConfigMapRequestCAS_FieldSubPathValue) AsConditionalStatePathValue() (config_map.ConfigMap_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateConfigMapRequestCAS_FieldSubPathValue) SetTo(target **UpdateConfigMapRequest_CAS) {
	if *target == nil {
		*target = new(UpdateConfigMapRequest_CAS)
	}
	switch fpvs.Selector() {
	case UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState:
		fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue).SetTo(&(*target).ConditionalState)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateConfigMapRequestCAS_FieldSubPathValue) CompareWith(source *UpdateConfigMapRequest_CAS) (int, bool) {
	switch fpvs.Selector() {
	case UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState:
		return fpvs.subPathValue.(config_map.ConfigMap_FieldPathValue).CompareWith(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateConfigMapRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseUpdateConfigMapRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) UpdateConfigMapRequestCAS_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateConfigMapRequestCAS_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateConfigMapRequestCAS_FieldTerminalPathArrayItemValue struct {
	UpdateConfigMapRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateConfigMapRequestCAS_FieldPathArrayItemValue = (*UpdateConfigMapRequestCAS_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateConfigMapRequestCAS_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateConfigMapRequest_CAS) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'CAS'
func (fpaiv *UpdateConfigMapRequestCAS_FieldTerminalPathArrayItemValue) ContainsValue(source *UpdateConfigMapRequest_CAS) bool {
	slice := fpaiv.UpdateConfigMapRequestCAS_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 UpdateConfigMapRequestCAS_FieldSubPathArrayItemValue struct {
	UpdateConfigMapRequestCAS_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

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

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

func MustParseUpdateConfigMapRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateConfigMapRequestCAS_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateConfigMapRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateConfigMapRequestCAS_FieldTerminalPathArrayOfValues struct {
	UpdateConfigMapRequestCAS_FieldTerminalPath
	values interface{}
}

var _ UpdateConfigMapRequestCAS_FieldPathArrayOfValues = (*UpdateConfigMapRequestCAS_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateConfigMapRequestCAS_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateConfigMapRequestCAS_FieldPathSelectorConditionalState:
		for _, v := range fpaov.values.([]*config_map.ConfigMap) {
			values = append(values, v)
		}
	case UpdateConfigMapRequestCAS_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*config_map.ConfigMap_FieldMask) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateConfigMapRequestCAS_FieldTerminalPathArrayOfValues) AsConditionalStateArrayOfValues() ([]*config_map.ConfigMap, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap)
	return res, ok
}
func (fpaov *UpdateConfigMapRequestCAS_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*config_map.ConfigMap_FieldMask, bool) {
	res, ok := fpaov.values.([]*config_map.ConfigMap_FieldMask)
	return res, ok
}

type UpdateConfigMapRequestCAS_FieldSubPathArrayOfValues struct {
	UpdateConfigMapRequestCAS_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateConfigMapRequestCAS_FieldPathArrayOfValues = (*UpdateConfigMapRequestCAS_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateConfigMapRequestCAS_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateConfigMapRequestCAS_FieldSubPathArrayOfValues) AsConditionalStatePathArrayOfValues() (config_map.ConfigMap_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(config_map.ConfigMap_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeleteConfigMapRequest_FieldPathSelector int32

const (
	DeleteConfigMapRequest_FieldPathSelectorName DeleteConfigMapRequest_FieldPathSelector = 0
)

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

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

func ParseDeleteConfigMapRequest_FieldPath(rawField string) (DeleteConfigMapRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeleteConfigMapRequest_FieldPath(fp)
}

func MustParseDeleteConfigMapRequest_FieldPath(rawField string) DeleteConfigMapRequest_FieldPath {
	fp, err := ParseDeleteConfigMapRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeleteConfigMapRequest_FieldTerminalPath struct {
	selector DeleteConfigMapRequest_FieldPathSelector
}

var _ DeleteConfigMapRequest_FieldPath = (*DeleteConfigMapRequest_FieldTerminalPath)(nil)

func (fp *DeleteConfigMapRequest_FieldTerminalPath) Selector() DeleteConfigMapRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *DeleteConfigMapRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*DeleteConfigMapRequest))
}

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

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

func (fp *DeleteConfigMapRequest_FieldTerminalPath) WithIValue(value interface{}) DeleteConfigMapRequest_FieldPathValue {
	switch fp.selector {
	case DeleteConfigMapRequest_FieldPathSelectorName:
		return &DeleteConfigMapRequest_FieldTerminalPathValue{DeleteConfigMapRequest_FieldTerminalPath: *fp, value: value.(*config_map.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteConfigMapRequest: %d", fp.selector))
	}
}

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

func (fp *DeleteConfigMapRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeleteConfigMapRequest_FieldPathArrayOfValues {
	fpaov := &DeleteConfigMapRequest_FieldTerminalPathArrayOfValues{DeleteConfigMapRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeleteConfigMapRequest_FieldPathSelectorName:
		return &DeleteConfigMapRequest_FieldTerminalPathArrayOfValues{DeleteConfigMapRequest_FieldTerminalPath: *fp, values: values.([]*config_map.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteConfigMapRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseDeleteConfigMapRequest_FieldPathValue(pathStr, valueStr string) DeleteConfigMapRequest_FieldPathValue {
	fpv, err := ParseDeleteConfigMapRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeleteConfigMapRequest_FieldTerminalPathValue struct {
	DeleteConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteConfigMapRequest_FieldPathValue = (*DeleteConfigMapRequest_FieldTerminalPathValue)(nil)

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

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

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

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

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

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

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

func MustParseDeleteConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr string) DeleteConfigMapRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseDeleteConfigMapRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeleteConfigMapRequest_FieldTerminalPathArrayItemValue struct {
	DeleteConfigMapRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteConfigMapRequest_FieldPathArrayItemValue = (*DeleteConfigMapRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeleteConfigMapRequest_FieldTerminalPathArrayItemValue) GetSingle(source *DeleteConfigMapRequest) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'DeleteConfigMapRequest'
func (fpaiv *DeleteConfigMapRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *DeleteConfigMapRequest) bool {
	slice := fpaiv.DeleteConfigMapRequest_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
}

// DeleteConfigMapRequest_FieldPathArrayOfValues allows storing slice of values for DeleteConfigMapRequest fields according to their type
type DeleteConfigMapRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeleteConfigMapRequest_FieldPath
}

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

func MustParseDeleteConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr string) DeleteConfigMapRequest_FieldPathArrayOfValues {
	fpaov, err := ParseDeleteConfigMapRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeleteConfigMapRequest_FieldTerminalPathArrayOfValues struct {
	DeleteConfigMapRequest_FieldTerminalPath
	values interface{}
}

var _ DeleteConfigMapRequest_FieldPathArrayOfValues = (*DeleteConfigMapRequest_FieldTerminalPathArrayOfValues)(nil)

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