secret_service.pb.fieldpath.go

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

package secret_client

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

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

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

// proto imports
import (
	project "github.com/cloudwan/edgelq-sdk/secrets/resources/v1alpha2/project"
	secret "github.com/cloudwan/edgelq-sdk/secrets/resources/v1alpha2/secret"
	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 (
	_ = &project.Project{}
	_ = &secret.Secret{}
	_ = &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 GetSecretRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() GetSecretRequest_FieldPathSelector
	Get(source *GetSecretRequest) []interface{}
	GetSingle(source *GetSecretRequest) (interface{}, bool)
	ClearValue(item *GetSecretRequest)

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

type GetSecretRequest_FieldPathSelector int32

const (
	GetSecretRequest_FieldPathSelectorName      GetSecretRequest_FieldPathSelector = 0
	GetSecretRequest_FieldPathSelectorFieldMask GetSecretRequest_FieldPathSelector = 1
	GetSecretRequest_FieldPathSelectorView      GetSecretRequest_FieldPathSelector = 2
)

func (s GetSecretRequest_FieldPathSelector) String() string {
	switch s {
	case GetSecretRequest_FieldPathSelectorName:
		return "name"
	case GetSecretRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case GetSecretRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for GetSecretRequest: %d", s))
	}
}

func BuildGetSecretRequest_FieldPath(fp gotenobject.RawFieldPath) (GetSecretRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object GetSecretRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &GetSecretRequest_FieldTerminalPath{selector: GetSecretRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &GetSecretRequest_FieldTerminalPath{selector: GetSecretRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &GetSecretRequest_FieldTerminalPath{selector: GetSecretRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object GetSecretRequest", fp)
}

func ParseGetSecretRequest_FieldPath(rawField string) (GetSecretRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildGetSecretRequest_FieldPath(fp)
}

func MustParseGetSecretRequest_FieldPath(rawField string) GetSecretRequest_FieldPath {
	fp, err := ParseGetSecretRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type GetSecretRequest_FieldTerminalPath struct {
	selector GetSecretRequest_FieldPathSelector
}

var _ GetSecretRequest_FieldPath = (*GetSecretRequest_FieldTerminalPath)(nil)

func (fp *GetSecretRequest_FieldTerminalPath) Selector() GetSecretRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *GetSecretRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case GetSecretRequest_FieldPathSelectorName:
		return (*secret.Reference)(nil)
	case GetSecretRequest_FieldPathSelectorFieldMask:
		return (*secret.Secret_FieldMask)(nil)
	case GetSecretRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for GetSecretRequest: %d", fp.selector))
	}
}

func (fp *GetSecretRequest_FieldTerminalPath) ClearValue(item *GetSecretRequest) {
	if item != nil {
		switch fp.selector {
		case GetSecretRequest_FieldPathSelectorName:
			item.Name = nil
		case GetSecretRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case GetSecretRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for GetSecretRequest: %d", fp.selector))
		}
	}
}

func (fp *GetSecretRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*GetSecretRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *GetSecretRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == GetSecretRequest_FieldPathSelectorName ||
		fp.selector == GetSecretRequest_FieldPathSelectorFieldMask ||
		fp.selector == GetSecretRequest_FieldPathSelectorView
}

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

func (fp *GetSecretRequest_FieldTerminalPath) WithIValue(value interface{}) GetSecretRequest_FieldPathValue {
	switch fp.selector {
	case GetSecretRequest_FieldPathSelectorName:
		return &GetSecretRequest_FieldTerminalPathValue{GetSecretRequest_FieldTerminalPath: *fp, value: value.(*secret.Reference)}
	case GetSecretRequest_FieldPathSelectorFieldMask:
		return &GetSecretRequest_FieldTerminalPathValue{GetSecretRequest_FieldTerminalPath: *fp, value: value.(*secret.Secret_FieldMask)}
	case GetSecretRequest_FieldPathSelectorView:
		return &GetSecretRequest_FieldTerminalPathValue{GetSecretRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetSecretRequest: %d", fp.selector))
	}
}

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

func (fp *GetSecretRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) GetSecretRequest_FieldPathArrayOfValues {
	fpaov := &GetSecretRequest_FieldTerminalPathArrayOfValues{GetSecretRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case GetSecretRequest_FieldPathSelectorName:
		return &GetSecretRequest_FieldTerminalPathArrayOfValues{GetSecretRequest_FieldTerminalPath: *fp, values: values.([]*secret.Reference)}
	case GetSecretRequest_FieldPathSelectorFieldMask:
		return &GetSecretRequest_FieldTerminalPathArrayOfValues{GetSecretRequest_FieldTerminalPath: *fp, values: values.([]*secret.Secret_FieldMask)}
	case GetSecretRequest_FieldPathSelectorView:
		return &GetSecretRequest_FieldTerminalPathArrayOfValues{GetSecretRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetSecretRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseGetSecretRequest_FieldPathValue(pathStr, valueStr string) GetSecretRequest_FieldPathValue {
	fpv, err := ParseGetSecretRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type GetSecretRequest_FieldTerminalPathValue struct {
	GetSecretRequest_FieldTerminalPath
	value interface{}
}

var _ GetSecretRequest_FieldPathValue = (*GetSecretRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object GetSecretRequest
func (fpv *GetSecretRequest_FieldTerminalPathValue) SetTo(target **GetSecretRequest) {
	if *target == nil {
		*target = new(GetSecretRequest)
	}
	switch fpv.selector {
	case GetSecretRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*secret.Reference)
	case GetSecretRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*secret.Secret_FieldMask)
	case GetSecretRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for GetSecretRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'GetSecretRequest_FieldTerminalPathValue' with the value under path in 'GetSecretRequest'.
func (fpv *GetSecretRequest_FieldTerminalPathValue) CompareWith(source *GetSecretRequest) (int, bool) {
	switch fpv.selector {
	case GetSecretRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*secret.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 GetSecretRequest_FieldPathSelectorFieldMask:
		return 0, false
	case GetSecretRequest_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 GetSecretRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseGetSecretRequest_FieldPathArrayItemValue(pathStr, valueStr string) GetSecretRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseGetSecretRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type GetSecretRequest_FieldTerminalPathArrayItemValue struct {
	GetSecretRequest_FieldTerminalPath
	value interface{}
}

var _ GetSecretRequest_FieldPathArrayItemValue = (*GetSecretRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *GetSecretRequest_FieldTerminalPathArrayItemValue) GetSingle(source *GetSecretRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetSecretRequest_FieldPathArrayOfValues allows storing slice of values for GetSecretRequest fields according to their type
type GetSecretRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	GetSecretRequest_FieldPath
}

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

func MustParseGetSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr string) GetSecretRequest_FieldPathArrayOfValues {
	fpaov, err := ParseGetSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type GetSecretRequest_FieldTerminalPathArrayOfValues struct {
	GetSecretRequest_FieldTerminalPath
	values interface{}
}

var _ GetSecretRequest_FieldPathArrayOfValues = (*GetSecretRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *GetSecretRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case GetSecretRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*secret.Reference) {
			values = append(values, v)
		}
	case GetSecretRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*secret.Secret_FieldMask) {
			values = append(values, v)
		}
	case GetSecretRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *GetSecretRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*secret.Reference, bool) {
	res, ok := fpaov.values.([]*secret.Reference)
	return res, ok
}
func (fpaov *GetSecretRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*secret.Secret_FieldMask, bool) {
	res, ok := fpaov.values.([]*secret.Secret_FieldMask)
	return res, ok
}
func (fpaov *GetSecretRequest_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 BatchGetSecretsRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetSecretsRequest_FieldPathSelector
	Get(source *BatchGetSecretsRequest) []interface{}
	GetSingle(source *BatchGetSecretsRequest) (interface{}, bool)
	ClearValue(item *BatchGetSecretsRequest)

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

type BatchGetSecretsRequest_FieldPathSelector int32

const (
	BatchGetSecretsRequest_FieldPathSelectorNames     BatchGetSecretsRequest_FieldPathSelector = 0
	BatchGetSecretsRequest_FieldPathSelectorFieldMask BatchGetSecretsRequest_FieldPathSelector = 1
	BatchGetSecretsRequest_FieldPathSelectorView      BatchGetSecretsRequest_FieldPathSelector = 2
)

func (s BatchGetSecretsRequest_FieldPathSelector) String() string {
	switch s {
	case BatchGetSecretsRequest_FieldPathSelectorNames:
		return "names"
	case BatchGetSecretsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case BatchGetSecretsRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsRequest: %d", s))
	}
}

func BuildBatchGetSecretsRequest_FieldPath(fp gotenobject.RawFieldPath) (BatchGetSecretsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetSecretsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "names":
			return &BatchGetSecretsRequest_FieldTerminalPath{selector: BatchGetSecretsRequest_FieldPathSelectorNames}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &BatchGetSecretsRequest_FieldTerminalPath{selector: BatchGetSecretsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &BatchGetSecretsRequest_FieldTerminalPath{selector: BatchGetSecretsRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetSecretsRequest", fp)
}

func ParseBatchGetSecretsRequest_FieldPath(rawField string) (BatchGetSecretsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetSecretsRequest_FieldPath(fp)
}

func MustParseBatchGetSecretsRequest_FieldPath(rawField string) BatchGetSecretsRequest_FieldPath {
	fp, err := ParseBatchGetSecretsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetSecretsRequest_FieldTerminalPath struct {
	selector BatchGetSecretsRequest_FieldPathSelector
}

var _ BatchGetSecretsRequest_FieldPath = (*BatchGetSecretsRequest_FieldTerminalPath)(nil)

func (fp *BatchGetSecretsRequest_FieldTerminalPath) Selector() BatchGetSecretsRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *BatchGetSecretsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetSecretsRequest_FieldPathSelectorNames:
		return ([]*secret.Reference)(nil)
	case BatchGetSecretsRequest_FieldPathSelectorFieldMask:
		return (*secret.Secret_FieldMask)(nil)
	case BatchGetSecretsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsRequest: %d", fp.selector))
	}
}

func (fp *BatchGetSecretsRequest_FieldTerminalPath) ClearValue(item *BatchGetSecretsRequest) {
	if item != nil {
		switch fp.selector {
		case BatchGetSecretsRequest_FieldPathSelectorNames:
			item.Names = nil
		case BatchGetSecretsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case BatchGetSecretsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetSecretsRequest: %d", fp.selector))
		}
	}
}

func (fp *BatchGetSecretsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetSecretsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *BatchGetSecretsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == BatchGetSecretsRequest_FieldPathSelectorNames ||
		fp.selector == BatchGetSecretsRequest_FieldPathSelectorFieldMask ||
		fp.selector == BatchGetSecretsRequest_FieldPathSelectorView
}

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

func (fp *BatchGetSecretsRequest_FieldTerminalPath) WithIValue(value interface{}) BatchGetSecretsRequest_FieldPathValue {
	switch fp.selector {
	case BatchGetSecretsRequest_FieldPathSelectorNames:
		return &BatchGetSecretsRequest_FieldTerminalPathValue{BatchGetSecretsRequest_FieldTerminalPath: *fp, value: value.([]*secret.Reference)}
	case BatchGetSecretsRequest_FieldPathSelectorFieldMask:
		return &BatchGetSecretsRequest_FieldTerminalPathValue{BatchGetSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.Secret_FieldMask)}
	case BatchGetSecretsRequest_FieldPathSelectorView:
		return &BatchGetSecretsRequest_FieldTerminalPathValue{BatchGetSecretsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsRequest: %d", fp.selector))
	}
}

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

func (fp *BatchGetSecretsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetSecretsRequest_FieldPathArrayOfValues {
	fpaov := &BatchGetSecretsRequest_FieldTerminalPathArrayOfValues{BatchGetSecretsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetSecretsRequest_FieldPathSelectorNames:
		return &BatchGetSecretsRequest_FieldTerminalPathArrayOfValues{BatchGetSecretsRequest_FieldTerminalPath: *fp, values: values.([][]*secret.Reference)}
	case BatchGetSecretsRequest_FieldPathSelectorFieldMask:
		return &BatchGetSecretsRequest_FieldTerminalPathArrayOfValues{BatchGetSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.Secret_FieldMask)}
	case BatchGetSecretsRequest_FieldPathSelectorView:
		return &BatchGetSecretsRequest_FieldTerminalPathArrayOfValues{BatchGetSecretsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsRequest: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetSecretsRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetSecretsRequest_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetSecretsRequest_FieldPathSelectorNames:
		return &BatchGetSecretsRequest_FieldTerminalPathArrayItemValue{BatchGetSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsRequest: %d", fp.selector))
	}
}

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

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

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

func MustParseBatchGetSecretsRequest_FieldPathValue(pathStr, valueStr string) BatchGetSecretsRequest_FieldPathValue {
	fpv, err := ParseBatchGetSecretsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetSecretsRequest_FieldTerminalPathValue struct {
	BatchGetSecretsRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetSecretsRequest_FieldPathValue = (*BatchGetSecretsRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object BatchGetSecretsRequest
func (fpv *BatchGetSecretsRequest_FieldTerminalPathValue) SetTo(target **BatchGetSecretsRequest) {
	if *target == nil {
		*target = new(BatchGetSecretsRequest)
	}
	switch fpv.selector {
	case BatchGetSecretsRequest_FieldPathSelectorNames:
		(*target).Names = fpv.value.([]*secret.Reference)
	case BatchGetSecretsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*secret.Secret_FieldMask)
	case BatchGetSecretsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsRequest: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseBatchGetSecretsRequest_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetSecretsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetSecretsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetSecretsRequest_FieldTerminalPathArrayItemValue struct {
	BatchGetSecretsRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetSecretsRequest_FieldPathArrayItemValue = (*BatchGetSecretsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *BatchGetSecretsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetSecretsRequest) (interface{}, bool) {
	return nil, false
}

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

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

// BatchGetSecretsRequest_FieldPathArrayOfValues allows storing slice of values for BatchGetSecretsRequest fields according to their type
type BatchGetSecretsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetSecretsRequest_FieldPath
}

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

func MustParseBatchGetSecretsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetSecretsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetSecretsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetSecretsRequest_FieldTerminalPathArrayOfValues struct {
	BatchGetSecretsRequest_FieldTerminalPath
	values interface{}
}

var _ BatchGetSecretsRequest_FieldPathArrayOfValues = (*BatchGetSecretsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetSecretsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetSecretsRequest_FieldPathSelectorNames:
		for _, v := range fpaov.values.([][]*secret.Reference) {
			values = append(values, v)
		}
	case BatchGetSecretsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*secret.Secret_FieldMask) {
			values = append(values, v)
		}
	case BatchGetSecretsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetSecretsRequest_FieldTerminalPathArrayOfValues) AsNamesArrayOfValues() ([][]*secret.Reference, bool) {
	res, ok := fpaov.values.([][]*secret.Reference)
	return res, ok
}
func (fpaov *BatchGetSecretsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*secret.Secret_FieldMask, bool) {
	res, ok := fpaov.values.([]*secret.Secret_FieldMask)
	return res, ok
}
func (fpaov *BatchGetSecretsRequest_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 BatchGetSecretsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetSecretsResponse_FieldPathSelector
	Get(source *BatchGetSecretsResponse) []interface{}
	GetSingle(source *BatchGetSecretsResponse) (interface{}, bool)
	ClearValue(item *BatchGetSecretsResponse)

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

type BatchGetSecretsResponse_FieldPathSelector int32

const (
	BatchGetSecretsResponse_FieldPathSelectorSecrets BatchGetSecretsResponse_FieldPathSelector = 0
	BatchGetSecretsResponse_FieldPathSelectorMissing BatchGetSecretsResponse_FieldPathSelector = 1
)

func (s BatchGetSecretsResponse_FieldPathSelector) String() string {
	switch s {
	case BatchGetSecretsResponse_FieldPathSelectorSecrets:
		return "secrets"
	case BatchGetSecretsResponse_FieldPathSelectorMissing:
		return "missing"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsResponse: %d", s))
	}
}

func BuildBatchGetSecretsResponse_FieldPath(fp gotenobject.RawFieldPath) (BatchGetSecretsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetSecretsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "secrets":
			return &BatchGetSecretsResponse_FieldTerminalPath{selector: BatchGetSecretsResponse_FieldPathSelectorSecrets}, nil
		case "missing":
			return &BatchGetSecretsResponse_FieldTerminalPath{selector: BatchGetSecretsResponse_FieldPathSelectorMissing}, nil
		}
	} else {
		switch fp[0] {
		case "secrets":
			if subpath, err := secret.BuildSecret_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &BatchGetSecretsResponse_FieldSubPath{selector: BatchGetSecretsResponse_FieldPathSelectorSecrets, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetSecretsResponse", fp)
}

func ParseBatchGetSecretsResponse_FieldPath(rawField string) (BatchGetSecretsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetSecretsResponse_FieldPath(fp)
}

func MustParseBatchGetSecretsResponse_FieldPath(rawField string) BatchGetSecretsResponse_FieldPath {
	fp, err := ParseBatchGetSecretsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetSecretsResponse_FieldTerminalPath struct {
	selector BatchGetSecretsResponse_FieldPathSelector
}

var _ BatchGetSecretsResponse_FieldPath = (*BatchGetSecretsResponse_FieldTerminalPath)(nil)

func (fp *BatchGetSecretsResponse_FieldTerminalPath) Selector() BatchGetSecretsResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *BatchGetSecretsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetSecretsResponse_FieldPathSelectorSecrets:
		return ([]*secret.Secret)(nil)
	case BatchGetSecretsResponse_FieldPathSelectorMissing:
		return ([]*secret.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsResponse: %d", fp.selector))
	}
}

func (fp *BatchGetSecretsResponse_FieldTerminalPath) ClearValue(item *BatchGetSecretsResponse) {
	if item != nil {
		switch fp.selector {
		case BatchGetSecretsResponse_FieldPathSelectorSecrets:
			item.Secrets = nil
		case BatchGetSecretsResponse_FieldPathSelectorMissing:
			item.Missing = nil
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetSecretsResponse: %d", fp.selector))
		}
	}
}

func (fp *BatchGetSecretsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetSecretsResponse))
}

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

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

func (fp *BatchGetSecretsResponse_FieldTerminalPath) WithIValue(value interface{}) BatchGetSecretsResponse_FieldPathValue {
	switch fp.selector {
	case BatchGetSecretsResponse_FieldPathSelectorSecrets:
		return &BatchGetSecretsResponse_FieldTerminalPathValue{BatchGetSecretsResponse_FieldTerminalPath: *fp, value: value.([]*secret.Secret)}
	case BatchGetSecretsResponse_FieldPathSelectorMissing:
		return &BatchGetSecretsResponse_FieldTerminalPathValue{BatchGetSecretsResponse_FieldTerminalPath: *fp, value: value.([]*secret.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsResponse: %d", fp.selector))
	}
}

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

func (fp *BatchGetSecretsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetSecretsResponse_FieldPathArrayOfValues {
	fpaov := &BatchGetSecretsResponse_FieldTerminalPathArrayOfValues{BatchGetSecretsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetSecretsResponse_FieldPathSelectorSecrets:
		return &BatchGetSecretsResponse_FieldTerminalPathArrayOfValues{BatchGetSecretsResponse_FieldTerminalPath: *fp, values: values.([][]*secret.Secret)}
	case BatchGetSecretsResponse_FieldPathSelectorMissing:
		return &BatchGetSecretsResponse_FieldTerminalPathArrayOfValues{BatchGetSecretsResponse_FieldTerminalPath: *fp, values: values.([][]*secret.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetSecretsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetSecretsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetSecretsResponse_FieldPathSelectorSecrets:
		return &BatchGetSecretsResponse_FieldTerminalPathArrayItemValue{BatchGetSecretsResponse_FieldTerminalPath: *fp, value: value.(*secret.Secret)}
	case BatchGetSecretsResponse_FieldPathSelectorMissing:
		return &BatchGetSecretsResponse_FieldTerminalPathArrayItemValue{BatchGetSecretsResponse_FieldTerminalPath: *fp, value: value.(*secret.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsResponse: %d", fp.selector))
	}
}

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

type BatchGetSecretsResponse_FieldSubPath struct {
	selector BatchGetSecretsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ BatchGetSecretsResponse_FieldPath = (*BatchGetSecretsResponse_FieldSubPath)(nil)

func (fps *BatchGetSecretsResponse_FieldSubPath) Selector() BatchGetSecretsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *BatchGetSecretsResponse_FieldSubPath) AsSecretsSubPath() (secret.Secret_FieldPath, bool) {
	res, ok := fps.subPath.(secret.Secret_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *BatchGetSecretsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*BatchGetSecretsResponse))
}

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

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

func (fps *BatchGetSecretsResponse_FieldSubPath) WithIValue(value interface{}) BatchGetSecretsResponse_FieldPathValue {
	return &BatchGetSecretsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *BatchGetSecretsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) BatchGetSecretsResponse_FieldPathArrayOfValues {
	return &BatchGetSecretsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *BatchGetSecretsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) BatchGetSecretsResponse_FieldPathArrayItemValue {
	return &BatchGetSecretsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseBatchGetSecretsResponse_FieldPathValue(pathStr, valueStr string) BatchGetSecretsResponse_FieldPathValue {
	fpv, err := ParseBatchGetSecretsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetSecretsResponse_FieldTerminalPathValue struct {
	BatchGetSecretsResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetSecretsResponse_FieldPathValue = (*BatchGetSecretsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetSecretsResponse' as interface{}
func (fpv *BatchGetSecretsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetSecretsResponse_FieldTerminalPathValue) AsSecretsValue() ([]*secret.Secret, bool) {
	res, ok := fpv.value.([]*secret.Secret)
	return res, ok
}
func (fpv *BatchGetSecretsResponse_FieldTerminalPathValue) AsMissingValue() ([]*secret.Reference, bool) {
	res, ok := fpv.value.([]*secret.Reference)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetSecretsResponse
func (fpv *BatchGetSecretsResponse_FieldTerminalPathValue) SetTo(target **BatchGetSecretsResponse) {
	if *target == nil {
		*target = new(BatchGetSecretsResponse)
	}
	switch fpv.selector {
	case BatchGetSecretsResponse_FieldPathSelectorSecrets:
		(*target).Secrets = fpv.value.([]*secret.Secret)
	case BatchGetSecretsResponse_FieldPathSelectorMissing:
		(*target).Missing = fpv.value.([]*secret.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetSecretsResponse: %d", fpv.selector))
	}
}

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

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

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

type BatchGetSecretsResponse_FieldSubPathValue struct {
	BatchGetSecretsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ BatchGetSecretsResponse_FieldPathValue = (*BatchGetSecretsResponse_FieldSubPathValue)(nil)

func (fpvs *BatchGetSecretsResponse_FieldSubPathValue) AsSecretsPathValue() (secret.Secret_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(secret.Secret_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseBatchGetSecretsResponse_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetSecretsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetSecretsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetSecretsResponse_FieldTerminalPathArrayItemValue struct {
	BatchGetSecretsResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetSecretsResponse_FieldPathArrayItemValue = (*BatchGetSecretsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetSecretsResponse as interface{}
func (fpaiv *BatchGetSecretsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetSecretsResponse_FieldTerminalPathArrayItemValue) AsSecretsItemValue() (*secret.Secret, bool) {
	res, ok := fpaiv.value.(*secret.Secret)
	return res, ok
}
func (fpaiv *BatchGetSecretsResponse_FieldTerminalPathArrayItemValue) AsMissingItemValue() (*secret.Reference, bool) {
	res, ok := fpaiv.value.(*secret.Reference)
	return res, ok
}

func (fpaiv *BatchGetSecretsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetSecretsResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *BatchGetSecretsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *BatchGetSecretsResponse_FieldSubPathArrayItemValue) AsSecretsPathItemValue() (secret.Secret_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(secret.Secret_FieldPathArrayItemValue)
	return res, ok
}

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

// BatchGetSecretsResponse_FieldPathArrayOfValues allows storing slice of values for BatchGetSecretsResponse fields according to their type
type BatchGetSecretsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetSecretsResponse_FieldPath
}

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

func MustParseBatchGetSecretsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetSecretsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetSecretsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetSecretsResponse_FieldTerminalPathArrayOfValues struct {
	BatchGetSecretsResponse_FieldTerminalPath
	values interface{}
}

var _ BatchGetSecretsResponse_FieldPathArrayOfValues = (*BatchGetSecretsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetSecretsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetSecretsResponse_FieldPathSelectorSecrets:
		for _, v := range fpaov.values.([][]*secret.Secret) {
			values = append(values, v)
		}
	case BatchGetSecretsResponse_FieldPathSelectorMissing:
		for _, v := range fpaov.values.([][]*secret.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetSecretsResponse_FieldTerminalPathArrayOfValues) AsSecretsArrayOfValues() ([][]*secret.Secret, bool) {
	res, ok := fpaov.values.([][]*secret.Secret)
	return res, ok
}
func (fpaov *BatchGetSecretsResponse_FieldTerminalPathArrayOfValues) AsMissingArrayOfValues() ([][]*secret.Reference, bool) {
	res, ok := fpaov.values.([][]*secret.Reference)
	return res, ok
}

type BatchGetSecretsResponse_FieldSubPathArrayOfValues struct {
	BatchGetSecretsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ BatchGetSecretsResponse_FieldPathArrayOfValues = (*BatchGetSecretsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *BatchGetSecretsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *BatchGetSecretsResponse_FieldSubPathArrayOfValues) AsSecretsPathArrayOfValues() (secret.Secret_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(secret.Secret_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ListSecretsRequest_FieldPathSelector int32

const (
	ListSecretsRequest_FieldPathSelectorParent            ListSecretsRequest_FieldPathSelector = 0
	ListSecretsRequest_FieldPathSelectorPageSize          ListSecretsRequest_FieldPathSelector = 1
	ListSecretsRequest_FieldPathSelectorPageToken         ListSecretsRequest_FieldPathSelector = 2
	ListSecretsRequest_FieldPathSelectorOrderBy           ListSecretsRequest_FieldPathSelector = 3
	ListSecretsRequest_FieldPathSelectorFilter            ListSecretsRequest_FieldPathSelector = 4
	ListSecretsRequest_FieldPathSelectorFieldMask         ListSecretsRequest_FieldPathSelector = 5
	ListSecretsRequest_FieldPathSelectorView              ListSecretsRequest_FieldPathSelector = 6
	ListSecretsRequest_FieldPathSelectorIncludePagingInfo ListSecretsRequest_FieldPathSelector = 7
)

func (s ListSecretsRequest_FieldPathSelector) String() string {
	switch s {
	case ListSecretsRequest_FieldPathSelectorParent:
		return "parent"
	case ListSecretsRequest_FieldPathSelectorPageSize:
		return "page_size"
	case ListSecretsRequest_FieldPathSelectorPageToken:
		return "page_token"
	case ListSecretsRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case ListSecretsRequest_FieldPathSelectorFilter:
		return "filter"
	case ListSecretsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case ListSecretsRequest_FieldPathSelectorView:
		return "view"
	case ListSecretsRequest_FieldPathSelectorIncludePagingInfo:
		return "include_paging_info"
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsRequest: %d", s))
	}
}

func BuildListSecretsRequest_FieldPath(fp gotenobject.RawFieldPath) (ListSecretsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListSecretsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &ListSecretsRequest_FieldTerminalPath{selector: ListSecretsRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &ListSecretsRequest_FieldTerminalPath{selector: ListSecretsRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &ListSecretsRequest_FieldTerminalPath{selector: ListSecretsRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &ListSecretsRequest_FieldTerminalPath{selector: ListSecretsRequest_FieldPathSelectorOrderBy}, nil
		case "filter":
			return &ListSecretsRequest_FieldTerminalPath{selector: ListSecretsRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &ListSecretsRequest_FieldTerminalPath{selector: ListSecretsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &ListSecretsRequest_FieldTerminalPath{selector: ListSecretsRequest_FieldPathSelectorView}, nil
		case "include_paging_info", "includePagingInfo", "include-paging-info":
			return &ListSecretsRequest_FieldTerminalPath{selector: ListSecretsRequest_FieldPathSelectorIncludePagingInfo}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListSecretsRequest", fp)
}

func ParseListSecretsRequest_FieldPath(rawField string) (ListSecretsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListSecretsRequest_FieldPath(fp)
}

func MustParseListSecretsRequest_FieldPath(rawField string) ListSecretsRequest_FieldPath {
	fp, err := ParseListSecretsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListSecretsRequest_FieldTerminalPath struct {
	selector ListSecretsRequest_FieldPathSelector
}

var _ ListSecretsRequest_FieldPath = (*ListSecretsRequest_FieldTerminalPath)(nil)

func (fp *ListSecretsRequest_FieldTerminalPath) Selector() ListSecretsRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListSecretsRequest
func (fp *ListSecretsRequest_FieldTerminalPath) Get(source *ListSecretsRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListSecretsRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case ListSecretsRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case ListSecretsRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case ListSecretsRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case ListSecretsRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case ListSecretsRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case ListSecretsRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case ListSecretsRequest_FieldPathSelectorIncludePagingInfo:
			values = append(values, source.IncludePagingInfo)
		default:
			panic(fmt.Sprintf("Invalid selector for ListSecretsRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListSecretsRequest
func (fp *ListSecretsRequest_FieldTerminalPath) GetSingle(source *ListSecretsRequest) (interface{}, bool) {
	switch fp.selector {
	case ListSecretsRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case ListSecretsRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case ListSecretsRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case ListSecretsRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case ListSecretsRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case ListSecretsRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case ListSecretsRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case ListSecretsRequest_FieldPathSelectorIncludePagingInfo:
		return source.GetIncludePagingInfo(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListSecretsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListSecretsRequest_FieldPathSelectorParent:
		return (*secret.ParentName)(nil)
	case ListSecretsRequest_FieldPathSelectorPageSize:
		return int32(0)
	case ListSecretsRequest_FieldPathSelectorPageToken:
		return (*secret.PagerCursor)(nil)
	case ListSecretsRequest_FieldPathSelectorOrderBy:
		return (*secret.OrderBy)(nil)
	case ListSecretsRequest_FieldPathSelectorFilter:
		return (*secret.Filter)(nil)
	case ListSecretsRequest_FieldPathSelectorFieldMask:
		return (*secret.Secret_FieldMask)(nil)
	case ListSecretsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case ListSecretsRequest_FieldPathSelectorIncludePagingInfo:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsRequest: %d", fp.selector))
	}
}

func (fp *ListSecretsRequest_FieldTerminalPath) ClearValue(item *ListSecretsRequest) {
	if item != nil {
		switch fp.selector {
		case ListSecretsRequest_FieldPathSelectorParent:
			item.Parent = nil
		case ListSecretsRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case ListSecretsRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case ListSecretsRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case ListSecretsRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case ListSecretsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case ListSecretsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case ListSecretsRequest_FieldPathSelectorIncludePagingInfo:
			item.IncludePagingInfo = false
		default:
			panic(fmt.Sprintf("Invalid selector for ListSecretsRequest: %d", fp.selector))
		}
	}
}

func (fp *ListSecretsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListSecretsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListSecretsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListSecretsRequest_FieldPathSelectorParent ||
		fp.selector == ListSecretsRequest_FieldPathSelectorPageSize ||
		fp.selector == ListSecretsRequest_FieldPathSelectorPageToken ||
		fp.selector == ListSecretsRequest_FieldPathSelectorOrderBy ||
		fp.selector == ListSecretsRequest_FieldPathSelectorFilter ||
		fp.selector == ListSecretsRequest_FieldPathSelectorFieldMask ||
		fp.selector == ListSecretsRequest_FieldPathSelectorView ||
		fp.selector == ListSecretsRequest_FieldPathSelectorIncludePagingInfo
}

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

func (fp *ListSecretsRequest_FieldTerminalPath) WithIValue(value interface{}) ListSecretsRequest_FieldPathValue {
	switch fp.selector {
	case ListSecretsRequest_FieldPathSelectorParent:
		return &ListSecretsRequest_FieldTerminalPathValue{ListSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.ParentName)}
	case ListSecretsRequest_FieldPathSelectorPageSize:
		return &ListSecretsRequest_FieldTerminalPathValue{ListSecretsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case ListSecretsRequest_FieldPathSelectorPageToken:
		return &ListSecretsRequest_FieldTerminalPathValue{ListSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.PagerCursor)}
	case ListSecretsRequest_FieldPathSelectorOrderBy:
		return &ListSecretsRequest_FieldTerminalPathValue{ListSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.OrderBy)}
	case ListSecretsRequest_FieldPathSelectorFilter:
		return &ListSecretsRequest_FieldTerminalPathValue{ListSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.Filter)}
	case ListSecretsRequest_FieldPathSelectorFieldMask:
		return &ListSecretsRequest_FieldTerminalPathValue{ListSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.Secret_FieldMask)}
	case ListSecretsRequest_FieldPathSelectorView:
		return &ListSecretsRequest_FieldTerminalPathValue{ListSecretsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case ListSecretsRequest_FieldPathSelectorIncludePagingInfo:
		return &ListSecretsRequest_FieldTerminalPathValue{ListSecretsRequest_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsRequest: %d", fp.selector))
	}
}

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

func (fp *ListSecretsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListSecretsRequest_FieldPathArrayOfValues {
	fpaov := &ListSecretsRequest_FieldTerminalPathArrayOfValues{ListSecretsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListSecretsRequest_FieldPathSelectorParent:
		return &ListSecretsRequest_FieldTerminalPathArrayOfValues{ListSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.ParentName)}
	case ListSecretsRequest_FieldPathSelectorPageSize:
		return &ListSecretsRequest_FieldTerminalPathArrayOfValues{ListSecretsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListSecretsRequest_FieldPathSelectorPageToken:
		return &ListSecretsRequest_FieldTerminalPathArrayOfValues{ListSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.PagerCursor)}
	case ListSecretsRequest_FieldPathSelectorOrderBy:
		return &ListSecretsRequest_FieldTerminalPathArrayOfValues{ListSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.OrderBy)}
	case ListSecretsRequest_FieldPathSelectorFilter:
		return &ListSecretsRequest_FieldTerminalPathArrayOfValues{ListSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.Filter)}
	case ListSecretsRequest_FieldPathSelectorFieldMask:
		return &ListSecretsRequest_FieldTerminalPathArrayOfValues{ListSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.Secret_FieldMask)}
	case ListSecretsRequest_FieldPathSelectorView:
		return &ListSecretsRequest_FieldTerminalPathArrayOfValues{ListSecretsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case ListSecretsRequest_FieldPathSelectorIncludePagingInfo:
		return &ListSecretsRequest_FieldTerminalPathArrayOfValues{ListSecretsRequest_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseListSecretsRequest_FieldPathValue(pathStr, valueStr string) ListSecretsRequest_FieldPathValue {
	fpv, err := ParseListSecretsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListSecretsRequest_FieldTerminalPathValue struct {
	ListSecretsRequest_FieldTerminalPath
	value interface{}
}

var _ ListSecretsRequest_FieldPathValue = (*ListSecretsRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object ListSecretsRequest
func (fpv *ListSecretsRequest_FieldTerminalPathValue) SetTo(target **ListSecretsRequest) {
	if *target == nil {
		*target = new(ListSecretsRequest)
	}
	switch fpv.selector {
	case ListSecretsRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*secret.ParentName)
	case ListSecretsRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case ListSecretsRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*secret.PagerCursor)
	case ListSecretsRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*secret.OrderBy)
	case ListSecretsRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*secret.Filter)
	case ListSecretsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*secret.Secret_FieldMask)
	case ListSecretsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case ListSecretsRequest_FieldPathSelectorIncludePagingInfo:
		(*target).IncludePagingInfo = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListSecretsRequest_FieldTerminalPathValue' with the value under path in 'ListSecretsRequest'.
func (fpv *ListSecretsRequest_FieldTerminalPathValue) CompareWith(source *ListSecretsRequest) (int, bool) {
	switch fpv.selector {
	case ListSecretsRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*secret.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 ListSecretsRequest_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 ListSecretsRequest_FieldPathSelectorPageToken:
		return 0, false
	case ListSecretsRequest_FieldPathSelectorOrderBy:
		return 0, false
	case ListSecretsRequest_FieldPathSelectorFilter:
		return 0, false
	case ListSecretsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case ListSecretsRequest_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 ListSecretsRequest_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 ListSecretsRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseListSecretsRequest_FieldPathArrayItemValue(pathStr, valueStr string) ListSecretsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseListSecretsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListSecretsRequest_FieldTerminalPathArrayItemValue struct {
	ListSecretsRequest_FieldTerminalPath
	value interface{}
}

var _ ListSecretsRequest_FieldPathArrayItemValue = (*ListSecretsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ListSecretsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ListSecretsRequest) (interface{}, bool) {
	return nil, false
}

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

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

// ListSecretsRequest_FieldPathArrayOfValues allows storing slice of values for ListSecretsRequest fields according to their type
type ListSecretsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListSecretsRequest_FieldPath
}

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

func MustParseListSecretsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ListSecretsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseListSecretsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListSecretsRequest_FieldTerminalPathArrayOfValues struct {
	ListSecretsRequest_FieldTerminalPath
	values interface{}
}

var _ ListSecretsRequest_FieldPathArrayOfValues = (*ListSecretsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListSecretsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListSecretsRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*secret.ParentName) {
			values = append(values, v)
		}
	case ListSecretsRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListSecretsRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*secret.PagerCursor) {
			values = append(values, v)
		}
	case ListSecretsRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*secret.OrderBy) {
			values = append(values, v)
		}
	case ListSecretsRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*secret.Filter) {
			values = append(values, v)
		}
	case ListSecretsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*secret.Secret_FieldMask) {
			values = append(values, v)
		}
	case ListSecretsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case ListSecretsRequest_FieldPathSelectorIncludePagingInfo:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListSecretsRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*secret.ParentName, bool) {
	res, ok := fpaov.values.([]*secret.ParentName)
	return res, ok
}
func (fpaov *ListSecretsRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListSecretsRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*secret.PagerCursor, bool) {
	res, ok := fpaov.values.([]*secret.PagerCursor)
	return res, ok
}
func (fpaov *ListSecretsRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*secret.OrderBy, bool) {
	res, ok := fpaov.values.([]*secret.OrderBy)
	return res, ok
}
func (fpaov *ListSecretsRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*secret.Filter, bool) {
	res, ok := fpaov.values.([]*secret.Filter)
	return res, ok
}
func (fpaov *ListSecretsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*secret.Secret_FieldMask, bool) {
	res, ok := fpaov.values.([]*secret.Secret_FieldMask)
	return res, ok
}
func (fpaov *ListSecretsRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *ListSecretsRequest_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 ListSecretsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() ListSecretsResponse_FieldPathSelector
	Get(source *ListSecretsResponse) []interface{}
	GetSingle(source *ListSecretsResponse) (interface{}, bool)
	ClearValue(item *ListSecretsResponse)

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

type ListSecretsResponse_FieldPathSelector int32

const (
	ListSecretsResponse_FieldPathSelectorSecrets           ListSecretsResponse_FieldPathSelector = 0
	ListSecretsResponse_FieldPathSelectorPrevPageToken     ListSecretsResponse_FieldPathSelector = 1
	ListSecretsResponse_FieldPathSelectorNextPageToken     ListSecretsResponse_FieldPathSelector = 2
	ListSecretsResponse_FieldPathSelectorCurrentOffset     ListSecretsResponse_FieldPathSelector = 3
	ListSecretsResponse_FieldPathSelectorTotalResultsCount ListSecretsResponse_FieldPathSelector = 4
)

func (s ListSecretsResponse_FieldPathSelector) String() string {
	switch s {
	case ListSecretsResponse_FieldPathSelectorSecrets:
		return "secrets"
	case ListSecretsResponse_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case ListSecretsResponse_FieldPathSelectorNextPageToken:
		return "next_page_token"
	case ListSecretsResponse_FieldPathSelectorCurrentOffset:
		return "current_offset"
	case ListSecretsResponse_FieldPathSelectorTotalResultsCount:
		return "total_results_count"
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsResponse: %d", s))
	}
}

func BuildListSecretsResponse_FieldPath(fp gotenobject.RawFieldPath) (ListSecretsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListSecretsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "secrets":
			return &ListSecretsResponse_FieldTerminalPath{selector: ListSecretsResponse_FieldPathSelectorSecrets}, nil
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &ListSecretsResponse_FieldTerminalPath{selector: ListSecretsResponse_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &ListSecretsResponse_FieldTerminalPath{selector: ListSecretsResponse_FieldPathSelectorNextPageToken}, nil
		case "current_offset", "currentOffset", "current-offset":
			return &ListSecretsResponse_FieldTerminalPath{selector: ListSecretsResponse_FieldPathSelectorCurrentOffset}, nil
		case "total_results_count", "totalResultsCount", "total-results-count":
			return &ListSecretsResponse_FieldTerminalPath{selector: ListSecretsResponse_FieldPathSelectorTotalResultsCount}, nil
		}
	} else {
		switch fp[0] {
		case "secrets":
			if subpath, err := secret.BuildSecret_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListSecretsResponse_FieldSubPath{selector: ListSecretsResponse_FieldPathSelectorSecrets, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListSecretsResponse", fp)
}

func ParseListSecretsResponse_FieldPath(rawField string) (ListSecretsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListSecretsResponse_FieldPath(fp)
}

func MustParseListSecretsResponse_FieldPath(rawField string) ListSecretsResponse_FieldPath {
	fp, err := ParseListSecretsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListSecretsResponse_FieldTerminalPath struct {
	selector ListSecretsResponse_FieldPathSelector
}

var _ ListSecretsResponse_FieldPath = (*ListSecretsResponse_FieldTerminalPath)(nil)

func (fp *ListSecretsResponse_FieldTerminalPath) Selector() ListSecretsResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListSecretsResponse
func (fp *ListSecretsResponse_FieldTerminalPath) Get(source *ListSecretsResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListSecretsResponse_FieldPathSelectorSecrets:
			for _, value := range source.GetSecrets() {
				values = append(values, value)
			}
		case ListSecretsResponse_FieldPathSelectorPrevPageToken:
			if source.PrevPageToken != nil {
				values = append(values, source.PrevPageToken)
			}
		case ListSecretsResponse_FieldPathSelectorNextPageToken:
			if source.NextPageToken != nil {
				values = append(values, source.NextPageToken)
			}
		case ListSecretsResponse_FieldPathSelectorCurrentOffset:
			values = append(values, source.CurrentOffset)
		case ListSecretsResponse_FieldPathSelectorTotalResultsCount:
			values = append(values, source.TotalResultsCount)
		default:
			panic(fmt.Sprintf("Invalid selector for ListSecretsResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListSecretsResponse
func (fp *ListSecretsResponse_FieldTerminalPath) GetSingle(source *ListSecretsResponse) (interface{}, bool) {
	switch fp.selector {
	case ListSecretsResponse_FieldPathSelectorSecrets:
		res := source.GetSecrets()
		return res, res != nil
	case ListSecretsResponse_FieldPathSelectorPrevPageToken:
		res := source.GetPrevPageToken()
		return res, res != nil
	case ListSecretsResponse_FieldPathSelectorNextPageToken:
		res := source.GetNextPageToken()
		return res, res != nil
	case ListSecretsResponse_FieldPathSelectorCurrentOffset:
		return source.GetCurrentOffset(), source != nil
	case ListSecretsResponse_FieldPathSelectorTotalResultsCount:
		return source.GetTotalResultsCount(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListSecretsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListSecretsResponse_FieldPathSelectorSecrets:
		return ([]*secret.Secret)(nil)
	case ListSecretsResponse_FieldPathSelectorPrevPageToken:
		return (*secret.PagerCursor)(nil)
	case ListSecretsResponse_FieldPathSelectorNextPageToken:
		return (*secret.PagerCursor)(nil)
	case ListSecretsResponse_FieldPathSelectorCurrentOffset:
		return int32(0)
	case ListSecretsResponse_FieldPathSelectorTotalResultsCount:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsResponse: %d", fp.selector))
	}
}

func (fp *ListSecretsResponse_FieldTerminalPath) ClearValue(item *ListSecretsResponse) {
	if item != nil {
		switch fp.selector {
		case ListSecretsResponse_FieldPathSelectorSecrets:
			item.Secrets = nil
		case ListSecretsResponse_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case ListSecretsResponse_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		case ListSecretsResponse_FieldPathSelectorCurrentOffset:
			item.CurrentOffset = int32(0)
		case ListSecretsResponse_FieldPathSelectorTotalResultsCount:
			item.TotalResultsCount = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for ListSecretsResponse: %d", fp.selector))
		}
	}
}

func (fp *ListSecretsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListSecretsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListSecretsResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListSecretsResponse_FieldPathSelectorPrevPageToken ||
		fp.selector == ListSecretsResponse_FieldPathSelectorNextPageToken ||
		fp.selector == ListSecretsResponse_FieldPathSelectorCurrentOffset ||
		fp.selector == ListSecretsResponse_FieldPathSelectorTotalResultsCount
}

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

func (fp *ListSecretsResponse_FieldTerminalPath) WithIValue(value interface{}) ListSecretsResponse_FieldPathValue {
	switch fp.selector {
	case ListSecretsResponse_FieldPathSelectorSecrets:
		return &ListSecretsResponse_FieldTerminalPathValue{ListSecretsResponse_FieldTerminalPath: *fp, value: value.([]*secret.Secret)}
	case ListSecretsResponse_FieldPathSelectorPrevPageToken:
		return &ListSecretsResponse_FieldTerminalPathValue{ListSecretsResponse_FieldTerminalPath: *fp, value: value.(*secret.PagerCursor)}
	case ListSecretsResponse_FieldPathSelectorNextPageToken:
		return &ListSecretsResponse_FieldTerminalPathValue{ListSecretsResponse_FieldTerminalPath: *fp, value: value.(*secret.PagerCursor)}
	case ListSecretsResponse_FieldPathSelectorCurrentOffset:
		return &ListSecretsResponse_FieldTerminalPathValue{ListSecretsResponse_FieldTerminalPath: *fp, value: value.(int32)}
	case ListSecretsResponse_FieldPathSelectorTotalResultsCount:
		return &ListSecretsResponse_FieldTerminalPathValue{ListSecretsResponse_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsResponse: %d", fp.selector))
	}
}

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

func (fp *ListSecretsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListSecretsResponse_FieldPathArrayOfValues {
	fpaov := &ListSecretsResponse_FieldTerminalPathArrayOfValues{ListSecretsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListSecretsResponse_FieldPathSelectorSecrets:
		return &ListSecretsResponse_FieldTerminalPathArrayOfValues{ListSecretsResponse_FieldTerminalPath: *fp, values: values.([][]*secret.Secret)}
	case ListSecretsResponse_FieldPathSelectorPrevPageToken:
		return &ListSecretsResponse_FieldTerminalPathArrayOfValues{ListSecretsResponse_FieldTerminalPath: *fp, values: values.([]*secret.PagerCursor)}
	case ListSecretsResponse_FieldPathSelectorNextPageToken:
		return &ListSecretsResponse_FieldTerminalPathArrayOfValues{ListSecretsResponse_FieldTerminalPath: *fp, values: values.([]*secret.PagerCursor)}
	case ListSecretsResponse_FieldPathSelectorCurrentOffset:
		return &ListSecretsResponse_FieldTerminalPathArrayOfValues{ListSecretsResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListSecretsResponse_FieldPathSelectorTotalResultsCount:
		return &ListSecretsResponse_FieldTerminalPathArrayOfValues{ListSecretsResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *ListSecretsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListSecretsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case ListSecretsResponse_FieldPathSelectorSecrets:
		return &ListSecretsResponse_FieldTerminalPathArrayItemValue{ListSecretsResponse_FieldTerminalPath: *fp, value: value.(*secret.Secret)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsResponse: %d", fp.selector))
	}
}

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

type ListSecretsResponse_FieldSubPath struct {
	selector ListSecretsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListSecretsResponse_FieldPath = (*ListSecretsResponse_FieldSubPath)(nil)

func (fps *ListSecretsResponse_FieldSubPath) Selector() ListSecretsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ListSecretsResponse_FieldSubPath) AsSecretsSubPath() (secret.Secret_FieldPath, bool) {
	res, ok := fps.subPath.(secret.Secret_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *ListSecretsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListSecretsResponse))
}

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

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

func (fps *ListSecretsResponse_FieldSubPath) WithIValue(value interface{}) ListSecretsResponse_FieldPathValue {
	return &ListSecretsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ListSecretsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ListSecretsResponse_FieldPathArrayOfValues {
	return &ListSecretsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ListSecretsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ListSecretsResponse_FieldPathArrayItemValue {
	return &ListSecretsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseListSecretsResponse_FieldPathValue(pathStr, valueStr string) ListSecretsResponse_FieldPathValue {
	fpv, err := ParseListSecretsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListSecretsResponse_FieldTerminalPathValue struct {
	ListSecretsResponse_FieldTerminalPath
	value interface{}
}

var _ ListSecretsResponse_FieldPathValue = (*ListSecretsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListSecretsResponse' as interface{}
func (fpv *ListSecretsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListSecretsResponse_FieldTerminalPathValue) AsSecretsValue() ([]*secret.Secret, bool) {
	res, ok := fpv.value.([]*secret.Secret)
	return res, ok
}
func (fpv *ListSecretsResponse_FieldTerminalPathValue) AsPrevPageTokenValue() (*secret.PagerCursor, bool) {
	res, ok := fpv.value.(*secret.PagerCursor)
	return res, ok
}
func (fpv *ListSecretsResponse_FieldTerminalPathValue) AsNextPageTokenValue() (*secret.PagerCursor, bool) {
	res, ok := fpv.value.(*secret.PagerCursor)
	return res, ok
}
func (fpv *ListSecretsResponse_FieldTerminalPathValue) AsCurrentOffsetValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListSecretsResponse_FieldTerminalPathValue) AsTotalResultsCountValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object ListSecretsResponse
func (fpv *ListSecretsResponse_FieldTerminalPathValue) SetTo(target **ListSecretsResponse) {
	if *target == nil {
		*target = new(ListSecretsResponse)
	}
	switch fpv.selector {
	case ListSecretsResponse_FieldPathSelectorSecrets:
		(*target).Secrets = fpv.value.([]*secret.Secret)
	case ListSecretsResponse_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*secret.PagerCursor)
	case ListSecretsResponse_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*secret.PagerCursor)
	case ListSecretsResponse_FieldPathSelectorCurrentOffset:
		(*target).CurrentOffset = fpv.value.(int32)
	case ListSecretsResponse_FieldPathSelectorTotalResultsCount:
		(*target).TotalResultsCount = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for ListSecretsResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListSecretsResponse_FieldTerminalPathValue' with the value under path in 'ListSecretsResponse'.
func (fpv *ListSecretsResponse_FieldTerminalPathValue) CompareWith(source *ListSecretsResponse) (int, bool) {
	switch fpv.selector {
	case ListSecretsResponse_FieldPathSelectorSecrets:
		return 0, false
	case ListSecretsResponse_FieldPathSelectorPrevPageToken:
		return 0, false
	case ListSecretsResponse_FieldPathSelectorNextPageToken:
		return 0, false
	case ListSecretsResponse_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 ListSecretsResponse_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 ListSecretsResponse: %d", fpv.selector))
	}
}

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

type ListSecretsResponse_FieldSubPathValue struct {
	ListSecretsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListSecretsResponse_FieldPathValue = (*ListSecretsResponse_FieldSubPathValue)(nil)

func (fpvs *ListSecretsResponse_FieldSubPathValue) AsSecretsPathValue() (secret.Secret_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(secret.Secret_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseListSecretsResponse_FieldPathArrayItemValue(pathStr, valueStr string) ListSecretsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseListSecretsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListSecretsResponse_FieldTerminalPathArrayItemValue struct {
	ListSecretsResponse_FieldTerminalPath
	value interface{}
}

var _ ListSecretsResponse_FieldPathArrayItemValue = (*ListSecretsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListSecretsResponse as interface{}
func (fpaiv *ListSecretsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ListSecretsResponse_FieldTerminalPathArrayItemValue) AsSecretsItemValue() (*secret.Secret, bool) {
	res, ok := fpaiv.value.(*secret.Secret)
	return res, ok
}

func (fpaiv *ListSecretsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ListSecretsResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ListSecretsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListSecretsResponse_FieldSubPathArrayItemValue) AsSecretsPathItemValue() (secret.Secret_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(secret.Secret_FieldPathArrayItemValue)
	return res, ok
}

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

// ListSecretsResponse_FieldPathArrayOfValues allows storing slice of values for ListSecretsResponse fields according to their type
type ListSecretsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListSecretsResponse_FieldPath
}

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

func MustParseListSecretsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ListSecretsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseListSecretsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListSecretsResponse_FieldTerminalPathArrayOfValues struct {
	ListSecretsResponse_FieldTerminalPath
	values interface{}
}

var _ ListSecretsResponse_FieldPathArrayOfValues = (*ListSecretsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListSecretsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListSecretsResponse_FieldPathSelectorSecrets:
		for _, v := range fpaov.values.([][]*secret.Secret) {
			values = append(values, v)
		}
	case ListSecretsResponse_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*secret.PagerCursor) {
			values = append(values, v)
		}
	case ListSecretsResponse_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*secret.PagerCursor) {
			values = append(values, v)
		}
	case ListSecretsResponse_FieldPathSelectorCurrentOffset:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListSecretsResponse_FieldPathSelectorTotalResultsCount:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListSecretsResponse_FieldTerminalPathArrayOfValues) AsSecretsArrayOfValues() ([][]*secret.Secret, bool) {
	res, ok := fpaov.values.([][]*secret.Secret)
	return res, ok
}
func (fpaov *ListSecretsResponse_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*secret.PagerCursor, bool) {
	res, ok := fpaov.values.([]*secret.PagerCursor)
	return res, ok
}
func (fpaov *ListSecretsResponse_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*secret.PagerCursor, bool) {
	res, ok := fpaov.values.([]*secret.PagerCursor)
	return res, ok
}
func (fpaov *ListSecretsResponse_FieldTerminalPathArrayOfValues) AsCurrentOffsetArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListSecretsResponse_FieldTerminalPathArrayOfValues) AsTotalResultsCountArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

type ListSecretsResponse_FieldSubPathArrayOfValues struct {
	ListSecretsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListSecretsResponse_FieldPathArrayOfValues = (*ListSecretsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListSecretsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListSecretsResponse_FieldSubPathArrayOfValues) AsSecretsPathArrayOfValues() (secret.Secret_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(secret.Secret_FieldPathArrayOfValues)
	return res, ok
}

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

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

type WatchSecretRequest_FieldPathSelector int32

const (
	WatchSecretRequest_FieldPathSelectorName      WatchSecretRequest_FieldPathSelector = 0
	WatchSecretRequest_FieldPathSelectorFieldMask WatchSecretRequest_FieldPathSelector = 1
	WatchSecretRequest_FieldPathSelectorView      WatchSecretRequest_FieldPathSelector = 2
)

func (s WatchSecretRequest_FieldPathSelector) String() string {
	switch s {
	case WatchSecretRequest_FieldPathSelectorName:
		return "name"
	case WatchSecretRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchSecretRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretRequest: %d", s))
	}
}

func BuildWatchSecretRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchSecretRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchSecretRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &WatchSecretRequest_FieldTerminalPath{selector: WatchSecretRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchSecretRequest_FieldTerminalPath{selector: WatchSecretRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchSecretRequest_FieldTerminalPath{selector: WatchSecretRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchSecretRequest", fp)
}

func ParseWatchSecretRequest_FieldPath(rawField string) (WatchSecretRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchSecretRequest_FieldPath(fp)
}

func MustParseWatchSecretRequest_FieldPath(rawField string) WatchSecretRequest_FieldPath {
	fp, err := ParseWatchSecretRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchSecretRequest_FieldTerminalPath struct {
	selector WatchSecretRequest_FieldPathSelector
}

var _ WatchSecretRequest_FieldPath = (*WatchSecretRequest_FieldTerminalPath)(nil)

func (fp *WatchSecretRequest_FieldTerminalPath) Selector() WatchSecretRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchSecretRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchSecretRequest_FieldPathSelectorName:
		return (*secret.Reference)(nil)
	case WatchSecretRequest_FieldPathSelectorFieldMask:
		return (*secret.Secret_FieldMask)(nil)
	case WatchSecretRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretRequest: %d", fp.selector))
	}
}

func (fp *WatchSecretRequest_FieldTerminalPath) ClearValue(item *WatchSecretRequest) {
	if item != nil {
		switch fp.selector {
		case WatchSecretRequest_FieldPathSelectorName:
			item.Name = nil
		case WatchSecretRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchSecretRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for WatchSecretRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchSecretRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchSecretRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchSecretRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchSecretRequest_FieldPathSelectorName ||
		fp.selector == WatchSecretRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchSecretRequest_FieldPathSelectorView
}

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

func (fp *WatchSecretRequest_FieldTerminalPath) WithIValue(value interface{}) WatchSecretRequest_FieldPathValue {
	switch fp.selector {
	case WatchSecretRequest_FieldPathSelectorName:
		return &WatchSecretRequest_FieldTerminalPathValue{WatchSecretRequest_FieldTerminalPath: *fp, value: value.(*secret.Reference)}
	case WatchSecretRequest_FieldPathSelectorFieldMask:
		return &WatchSecretRequest_FieldTerminalPathValue{WatchSecretRequest_FieldTerminalPath: *fp, value: value.(*secret.Secret_FieldMask)}
	case WatchSecretRequest_FieldPathSelectorView:
		return &WatchSecretRequest_FieldTerminalPathValue{WatchSecretRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretRequest: %d", fp.selector))
	}
}

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

func (fp *WatchSecretRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchSecretRequest_FieldPathArrayOfValues {
	fpaov := &WatchSecretRequest_FieldTerminalPathArrayOfValues{WatchSecretRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchSecretRequest_FieldPathSelectorName:
		return &WatchSecretRequest_FieldTerminalPathArrayOfValues{WatchSecretRequest_FieldTerminalPath: *fp, values: values.([]*secret.Reference)}
	case WatchSecretRequest_FieldPathSelectorFieldMask:
		return &WatchSecretRequest_FieldTerminalPathArrayOfValues{WatchSecretRequest_FieldTerminalPath: *fp, values: values.([]*secret.Secret_FieldMask)}
	case WatchSecretRequest_FieldPathSelectorView:
		return &WatchSecretRequest_FieldTerminalPathArrayOfValues{WatchSecretRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchSecretRequest_FieldPathValue(pathStr, valueStr string) WatchSecretRequest_FieldPathValue {
	fpv, err := ParseWatchSecretRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchSecretRequest_FieldTerminalPathValue struct {
	WatchSecretRequest_FieldTerminalPath
	value interface{}
}

var _ WatchSecretRequest_FieldPathValue = (*WatchSecretRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object WatchSecretRequest
func (fpv *WatchSecretRequest_FieldTerminalPathValue) SetTo(target **WatchSecretRequest) {
	if *target == nil {
		*target = new(WatchSecretRequest)
	}
	switch fpv.selector {
	case WatchSecretRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*secret.Reference)
	case WatchSecretRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*secret.Secret_FieldMask)
	case WatchSecretRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchSecretRequest_FieldTerminalPathValue' with the value under path in 'WatchSecretRequest'.
func (fpv *WatchSecretRequest_FieldTerminalPathValue) CompareWith(source *WatchSecretRequest) (int, bool) {
	switch fpv.selector {
	case WatchSecretRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*secret.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 WatchSecretRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchSecretRequest_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 WatchSecretRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchSecretRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchSecretRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchSecretRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchSecretRequest_FieldTerminalPathArrayItemValue struct {
	WatchSecretRequest_FieldTerminalPath
	value interface{}
}

var _ WatchSecretRequest_FieldPathArrayItemValue = (*WatchSecretRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchSecretRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchSecretRequest) (interface{}, bool) {
	return nil, false
}

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

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

// WatchSecretRequest_FieldPathArrayOfValues allows storing slice of values for WatchSecretRequest fields according to their type
type WatchSecretRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchSecretRequest_FieldPath
}

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

func MustParseWatchSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchSecretRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchSecretRequest_FieldTerminalPathArrayOfValues struct {
	WatchSecretRequest_FieldTerminalPath
	values interface{}
}

var _ WatchSecretRequest_FieldPathArrayOfValues = (*WatchSecretRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchSecretRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchSecretRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*secret.Reference) {
			values = append(values, v)
		}
	case WatchSecretRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*secret.Secret_FieldMask) {
			values = append(values, v)
		}
	case WatchSecretRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchSecretRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*secret.Reference, bool) {
	res, ok := fpaov.values.([]*secret.Reference)
	return res, ok
}
func (fpaov *WatchSecretRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*secret.Secret_FieldMask, bool) {
	res, ok := fpaov.values.([]*secret.Secret_FieldMask)
	return res, ok
}
func (fpaov *WatchSecretRequest_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 WatchSecretResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchSecretResponse_FieldPathSelector
	Get(source *WatchSecretResponse) []interface{}
	GetSingle(source *WatchSecretResponse) (interface{}, bool)
	ClearValue(item *WatchSecretResponse)

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

type WatchSecretResponse_FieldPathSelector int32

const (
	WatchSecretResponse_FieldPathSelectorChange WatchSecretResponse_FieldPathSelector = 0
)

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

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

func ParseWatchSecretResponse_FieldPath(rawField string) (WatchSecretResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchSecretResponse_FieldPath(fp)
}

func MustParseWatchSecretResponse_FieldPath(rawField string) WatchSecretResponse_FieldPath {
	fp, err := ParseWatchSecretResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchSecretResponse_FieldTerminalPath struct {
	selector WatchSecretResponse_FieldPathSelector
}

var _ WatchSecretResponse_FieldPath = (*WatchSecretResponse_FieldTerminalPath)(nil)

func (fp *WatchSecretResponse_FieldTerminalPath) Selector() WatchSecretResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchSecretResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchSecretResponse_FieldPathSelectorChange:
		return (*secret.SecretChange)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretResponse: %d", fp.selector))
	}
}

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

func (fp *WatchSecretResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchSecretResponse))
}

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

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

func (fp *WatchSecretResponse_FieldTerminalPath) WithIValue(value interface{}) WatchSecretResponse_FieldPathValue {
	switch fp.selector {
	case WatchSecretResponse_FieldPathSelectorChange:
		return &WatchSecretResponse_FieldTerminalPathValue{WatchSecretResponse_FieldTerminalPath: *fp, value: value.(*secret.SecretChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretResponse: %d", fp.selector))
	}
}

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

func (fp *WatchSecretResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchSecretResponse_FieldPathArrayOfValues {
	fpaov := &WatchSecretResponse_FieldTerminalPathArrayOfValues{WatchSecretResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchSecretResponse_FieldPathSelectorChange:
		return &WatchSecretResponse_FieldTerminalPathArrayOfValues{WatchSecretResponse_FieldTerminalPath: *fp, values: values.([]*secret.SecretChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchSecretResponse_FieldPathValue(pathStr, valueStr string) WatchSecretResponse_FieldPathValue {
	fpv, err := ParseWatchSecretResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchSecretResponse_FieldTerminalPathValue struct {
	WatchSecretResponse_FieldTerminalPath
	value interface{}
}

var _ WatchSecretResponse_FieldPathValue = (*WatchSecretResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchSecretResponse' as interface{}
func (fpv *WatchSecretResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchSecretResponse_FieldTerminalPathValue) AsChangeValue() (*secret.SecretChange, bool) {
	res, ok := fpv.value.(*secret.SecretChange)
	return res, ok
}

// SetTo stores value for selected field for object WatchSecretResponse
func (fpv *WatchSecretResponse_FieldTerminalPathValue) SetTo(target **WatchSecretResponse) {
	if *target == nil {
		*target = new(WatchSecretResponse)
	}
	switch fpv.selector {
	case WatchSecretResponse_FieldPathSelectorChange:
		(*target).Change = fpv.value.(*secret.SecretChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretResponse: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseWatchSecretResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchSecretResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchSecretResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchSecretResponse_FieldTerminalPathArrayItemValue struct {
	WatchSecretResponse_FieldTerminalPath
	value interface{}
}

var _ WatchSecretResponse_FieldPathArrayItemValue = (*WatchSecretResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchSecretResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchSecretResponse) (interface{}, bool) {
	return nil, false
}

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

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

// WatchSecretResponse_FieldPathArrayOfValues allows storing slice of values for WatchSecretResponse fields according to their type
type WatchSecretResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchSecretResponse_FieldPath
}

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

func MustParseWatchSecretResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchSecretResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchSecretResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchSecretResponse_FieldTerminalPathArrayOfValues struct {
	WatchSecretResponse_FieldTerminalPath
	values interface{}
}

var _ WatchSecretResponse_FieldPathArrayOfValues = (*WatchSecretResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchSecretResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchSecretResponse_FieldPathSelectorChange:
		for _, v := range fpaov.values.([]*secret.SecretChange) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchSecretResponse_FieldTerminalPathArrayOfValues) AsChangeArrayOfValues() ([]*secret.SecretChange, bool) {
	res, ok := fpaov.values.([]*secret.SecretChange)
	return res, ok
}

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

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

type WatchSecretsRequest_FieldPathSelector int32

const (
	WatchSecretsRequest_FieldPathSelectorType         WatchSecretsRequest_FieldPathSelector = 0
	WatchSecretsRequest_FieldPathSelectorParent       WatchSecretsRequest_FieldPathSelector = 1
	WatchSecretsRequest_FieldPathSelectorPageSize     WatchSecretsRequest_FieldPathSelector = 2
	WatchSecretsRequest_FieldPathSelectorPageToken    WatchSecretsRequest_FieldPathSelector = 3
	WatchSecretsRequest_FieldPathSelectorOrderBy      WatchSecretsRequest_FieldPathSelector = 4
	WatchSecretsRequest_FieldPathSelectorResumeToken  WatchSecretsRequest_FieldPathSelector = 5
	WatchSecretsRequest_FieldPathSelectorStartingTime WatchSecretsRequest_FieldPathSelector = 6
	WatchSecretsRequest_FieldPathSelectorFilter       WatchSecretsRequest_FieldPathSelector = 7
	WatchSecretsRequest_FieldPathSelectorFieldMask    WatchSecretsRequest_FieldPathSelector = 8
	WatchSecretsRequest_FieldPathSelectorView         WatchSecretsRequest_FieldPathSelector = 9
	WatchSecretsRequest_FieldPathSelectorMaxChunkSize WatchSecretsRequest_FieldPathSelector = 10
)

func (s WatchSecretsRequest_FieldPathSelector) String() string {
	switch s {
	case WatchSecretsRequest_FieldPathSelectorType:
		return "type"
	case WatchSecretsRequest_FieldPathSelectorParent:
		return "parent"
	case WatchSecretsRequest_FieldPathSelectorPageSize:
		return "page_size"
	case WatchSecretsRequest_FieldPathSelectorPageToken:
		return "page_token"
	case WatchSecretsRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case WatchSecretsRequest_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchSecretsRequest_FieldPathSelectorStartingTime:
		return "starting_time"
	case WatchSecretsRequest_FieldPathSelectorFilter:
		return "filter"
	case WatchSecretsRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchSecretsRequest_FieldPathSelectorView:
		return "view"
	case WatchSecretsRequest_FieldPathSelectorMaxChunkSize:
		return "max_chunk_size"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsRequest: %d", s))
	}
}

func BuildWatchSecretsRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchSecretsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchSecretsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorType}, nil
		case "parent":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorOrderBy}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorResumeToken}, nil
		case "starting_time", "startingTime", "starting-time":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorStartingTime}, nil
		case "filter":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorView}, nil
		case "max_chunk_size", "maxChunkSize", "max-chunk-size":
			return &WatchSecretsRequest_FieldTerminalPath{selector: WatchSecretsRequest_FieldPathSelectorMaxChunkSize}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchSecretsRequest", fp)
}

func ParseWatchSecretsRequest_FieldPath(rawField string) (WatchSecretsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchSecretsRequest_FieldPath(fp)
}

func MustParseWatchSecretsRequest_FieldPath(rawField string) WatchSecretsRequest_FieldPath {
	fp, err := ParseWatchSecretsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchSecretsRequest_FieldTerminalPath struct {
	selector WatchSecretsRequest_FieldPathSelector
}

var _ WatchSecretsRequest_FieldPath = (*WatchSecretsRequest_FieldTerminalPath)(nil)

func (fp *WatchSecretsRequest_FieldTerminalPath) Selector() WatchSecretsRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchSecretsRequest
func (fp *WatchSecretsRequest_FieldTerminalPath) Get(source *WatchSecretsRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchSecretsRequest_FieldPathSelectorType:
			values = append(values, source.Type)
		case WatchSecretsRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case WatchSecretsRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case WatchSecretsRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case WatchSecretsRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case WatchSecretsRequest_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchSecretsRequest_FieldPathSelectorStartingTime:
			if source.StartingTime != nil {
				values = append(values, source.StartingTime)
			}
		case WatchSecretsRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case WatchSecretsRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchSecretsRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case WatchSecretsRequest_FieldPathSelectorMaxChunkSize:
			values = append(values, source.MaxChunkSize)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchSecretsRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchSecretsRequest
func (fp *WatchSecretsRequest_FieldTerminalPath) GetSingle(source *WatchSecretsRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchSecretsRequest_FieldPathSelectorType:
		return source.GetType(), source != nil
	case WatchSecretsRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case WatchSecretsRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case WatchSecretsRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case WatchSecretsRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case WatchSecretsRequest_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchSecretsRequest_FieldPathSelectorStartingTime:
		res := source.GetStartingTime()
		return res, res != nil
	case WatchSecretsRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case WatchSecretsRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchSecretsRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case WatchSecretsRequest_FieldPathSelectorMaxChunkSize:
		return source.GetMaxChunkSize(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchSecretsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchSecretsRequest_FieldPathSelectorType:
		return watch_type.WatchType_STATEFUL
	case WatchSecretsRequest_FieldPathSelectorParent:
		return (*secret.ParentReference)(nil)
	case WatchSecretsRequest_FieldPathSelectorPageSize:
		return int32(0)
	case WatchSecretsRequest_FieldPathSelectorPageToken:
		return (*secret.PagerCursor)(nil)
	case WatchSecretsRequest_FieldPathSelectorOrderBy:
		return (*secret.OrderBy)(nil)
	case WatchSecretsRequest_FieldPathSelectorResumeToken:
		return ""
	case WatchSecretsRequest_FieldPathSelectorStartingTime:
		return (*timestamp.Timestamp)(nil)
	case WatchSecretsRequest_FieldPathSelectorFilter:
		return (*secret.Filter)(nil)
	case WatchSecretsRequest_FieldPathSelectorFieldMask:
		return (*secret.Secret_FieldMask)(nil)
	case WatchSecretsRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case WatchSecretsRequest_FieldPathSelectorMaxChunkSize:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsRequest: %d", fp.selector))
	}
}

func (fp *WatchSecretsRequest_FieldTerminalPath) ClearValue(item *WatchSecretsRequest) {
	if item != nil {
		switch fp.selector {
		case WatchSecretsRequest_FieldPathSelectorType:
			item.Type = watch_type.WatchType_STATEFUL
		case WatchSecretsRequest_FieldPathSelectorParent:
			item.Parent = nil
		case WatchSecretsRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case WatchSecretsRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case WatchSecretsRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case WatchSecretsRequest_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchSecretsRequest_FieldPathSelectorStartingTime:
			item.StartingTime = nil
		case WatchSecretsRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case WatchSecretsRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchSecretsRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case WatchSecretsRequest_FieldPathSelectorMaxChunkSize:
			item.MaxChunkSize = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchSecretsRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchSecretsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchSecretsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchSecretsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchSecretsRequest_FieldPathSelectorType ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorParent ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorPageSize ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorPageToken ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorOrderBy ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorResumeToken ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorStartingTime ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorFilter ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorView ||
		fp.selector == WatchSecretsRequest_FieldPathSelectorMaxChunkSize
}

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

func (fp *WatchSecretsRequest_FieldTerminalPath) WithIValue(value interface{}) WatchSecretsRequest_FieldPathValue {
	switch fp.selector {
	case WatchSecretsRequest_FieldPathSelectorType:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(watch_type.WatchType)}
	case WatchSecretsRequest_FieldPathSelectorParent:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.ParentReference)}
	case WatchSecretsRequest_FieldPathSelectorPageSize:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case WatchSecretsRequest_FieldPathSelectorPageToken:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.PagerCursor)}
	case WatchSecretsRequest_FieldPathSelectorOrderBy:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.OrderBy)}
	case WatchSecretsRequest_FieldPathSelectorResumeToken:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(string)}
	case WatchSecretsRequest_FieldPathSelectorStartingTime:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(*timestamp.Timestamp)}
	case WatchSecretsRequest_FieldPathSelectorFilter:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.Filter)}
	case WatchSecretsRequest_FieldPathSelectorFieldMask:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(*secret.Secret_FieldMask)}
	case WatchSecretsRequest_FieldPathSelectorView:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case WatchSecretsRequest_FieldPathSelectorMaxChunkSize:
		return &WatchSecretsRequest_FieldTerminalPathValue{WatchSecretsRequest_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsRequest: %d", fp.selector))
	}
}

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

func (fp *WatchSecretsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchSecretsRequest_FieldPathArrayOfValues {
	fpaov := &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchSecretsRequest_FieldPathSelectorType:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]watch_type.WatchType)}
	case WatchSecretsRequest_FieldPathSelectorParent:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.ParentReference)}
	case WatchSecretsRequest_FieldPathSelectorPageSize:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case WatchSecretsRequest_FieldPathSelectorPageToken:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.PagerCursor)}
	case WatchSecretsRequest_FieldPathSelectorOrderBy:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.OrderBy)}
	case WatchSecretsRequest_FieldPathSelectorResumeToken:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchSecretsRequest_FieldPathSelectorStartingTime:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]*timestamp.Timestamp)}
	case WatchSecretsRequest_FieldPathSelectorFilter:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.Filter)}
	case WatchSecretsRequest_FieldPathSelectorFieldMask:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]*secret.Secret_FieldMask)}
	case WatchSecretsRequest_FieldPathSelectorView:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case WatchSecretsRequest_FieldPathSelectorMaxChunkSize:
		return &WatchSecretsRequest_FieldTerminalPathArrayOfValues{WatchSecretsRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchSecretsRequest_FieldPathValue(pathStr, valueStr string) WatchSecretsRequest_FieldPathValue {
	fpv, err := ParseWatchSecretsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchSecretsRequest_FieldTerminalPathValue struct {
	WatchSecretsRequest_FieldTerminalPath
	value interface{}
}

var _ WatchSecretsRequest_FieldPathValue = (*WatchSecretsRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object WatchSecretsRequest
func (fpv *WatchSecretsRequest_FieldTerminalPathValue) SetTo(target **WatchSecretsRequest) {
	if *target == nil {
		*target = new(WatchSecretsRequest)
	}
	switch fpv.selector {
	case WatchSecretsRequest_FieldPathSelectorType:
		(*target).Type = fpv.value.(watch_type.WatchType)
	case WatchSecretsRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*secret.ParentReference)
	case WatchSecretsRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case WatchSecretsRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*secret.PagerCursor)
	case WatchSecretsRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*secret.OrderBy)
	case WatchSecretsRequest_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchSecretsRequest_FieldPathSelectorStartingTime:
		(*target).StartingTime = fpv.value.(*timestamp.Timestamp)
	case WatchSecretsRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*secret.Filter)
	case WatchSecretsRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*secret.Secret_FieldMask)
	case WatchSecretsRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case WatchSecretsRequest_FieldPathSelectorMaxChunkSize:
		(*target).MaxChunkSize = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchSecretsRequest_FieldTerminalPathValue' with the value under path in 'WatchSecretsRequest'.
func (fpv *WatchSecretsRequest_FieldTerminalPathValue) CompareWith(source *WatchSecretsRequest) (int, bool) {
	switch fpv.selector {
	case WatchSecretsRequest_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 WatchSecretsRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*secret.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 WatchSecretsRequest_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 WatchSecretsRequest_FieldPathSelectorPageToken:
		return 0, false
	case WatchSecretsRequest_FieldPathSelectorOrderBy:
		return 0, false
	case WatchSecretsRequest_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 WatchSecretsRequest_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 WatchSecretsRequest_FieldPathSelectorFilter:
		return 0, false
	case WatchSecretsRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchSecretsRequest_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 WatchSecretsRequest_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 WatchSecretsRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchSecretsRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchSecretsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchSecretsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchSecretsRequest_FieldTerminalPathArrayItemValue struct {
	WatchSecretsRequest_FieldTerminalPath
	value interface{}
}

var _ WatchSecretsRequest_FieldPathArrayItemValue = (*WatchSecretsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchSecretsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchSecretsRequest) (interface{}, bool) {
	return nil, false
}

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

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

// WatchSecretsRequest_FieldPathArrayOfValues allows storing slice of values for WatchSecretsRequest fields according to their type
type WatchSecretsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchSecretsRequest_FieldPath
}

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

func MustParseWatchSecretsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchSecretsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchSecretsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchSecretsRequest_FieldTerminalPathArrayOfValues struct {
	WatchSecretsRequest_FieldTerminalPath
	values interface{}
}

var _ WatchSecretsRequest_FieldPathArrayOfValues = (*WatchSecretsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchSecretsRequest_FieldPathSelectorType:
		for _, v := range fpaov.values.([]watch_type.WatchType) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*secret.ParentReference) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*secret.PagerCursor) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*secret.OrderBy) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorStartingTime:
		for _, v := range fpaov.values.([]*timestamp.Timestamp) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*secret.Filter) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*secret.Secret_FieldMask) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case WatchSecretsRequest_FieldPathSelectorMaxChunkSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]watch_type.WatchType, bool) {
	res, ok := fpaov.values.([]watch_type.WatchType)
	return res, ok
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*secret.ParentReference, bool) {
	res, ok := fpaov.values.([]*secret.ParentReference)
	return res, ok
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*secret.PagerCursor, bool) {
	res, ok := fpaov.values.([]*secret.PagerCursor)
	return res, ok
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*secret.OrderBy, bool) {
	res, ok := fpaov.values.([]*secret.OrderBy)
	return res, ok
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsStartingTimeArrayOfValues() ([]*timestamp.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamp.Timestamp)
	return res, ok
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*secret.Filter, bool) {
	res, ok := fpaov.values.([]*secret.Filter)
	return res, ok
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*secret.Secret_FieldMask, bool) {
	res, ok := fpaov.values.([]*secret.Secret_FieldMask)
	return res, ok
}
func (fpaov *WatchSecretsRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *WatchSecretsRequest_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 WatchSecretsResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchSecretsResponse_FieldPathSelector
	Get(source *WatchSecretsResponse) []interface{}
	GetSingle(source *WatchSecretsResponse) (interface{}, bool)
	ClearValue(item *WatchSecretsResponse)

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

type WatchSecretsResponse_FieldPathSelector int32

const (
	WatchSecretsResponse_FieldPathSelectorSecretChanges   WatchSecretsResponse_FieldPathSelector = 0
	WatchSecretsResponse_FieldPathSelectorIsCurrent       WatchSecretsResponse_FieldPathSelector = 1
	WatchSecretsResponse_FieldPathSelectorPageTokenChange WatchSecretsResponse_FieldPathSelector = 2
	WatchSecretsResponse_FieldPathSelectorResumeToken     WatchSecretsResponse_FieldPathSelector = 3
	WatchSecretsResponse_FieldPathSelectorSnapshotSize    WatchSecretsResponse_FieldPathSelector = 4
	WatchSecretsResponse_FieldPathSelectorIsSoftReset     WatchSecretsResponse_FieldPathSelector = 5
	WatchSecretsResponse_FieldPathSelectorIsHardReset     WatchSecretsResponse_FieldPathSelector = 6
)

func (s WatchSecretsResponse_FieldPathSelector) String() string {
	switch s {
	case WatchSecretsResponse_FieldPathSelectorSecretChanges:
		return "secret_changes"
	case WatchSecretsResponse_FieldPathSelectorIsCurrent:
		return "is_current"
	case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
		return "page_token_change"
	case WatchSecretsResponse_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchSecretsResponse_FieldPathSelectorSnapshotSize:
		return "snapshot_size"
	case WatchSecretsResponse_FieldPathSelectorIsSoftReset:
		return "is_soft_reset"
	case WatchSecretsResponse_FieldPathSelectorIsHardReset:
		return "is_hard_reset"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", s))
	}
}

func BuildWatchSecretsResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchSecretsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchSecretsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "secret_changes", "secretChanges", "secret-changes":
			return &WatchSecretsResponse_FieldTerminalPath{selector: WatchSecretsResponse_FieldPathSelectorSecretChanges}, nil
		case "is_current", "isCurrent", "is-current":
			return &WatchSecretsResponse_FieldTerminalPath{selector: WatchSecretsResponse_FieldPathSelectorIsCurrent}, nil
		case "page_token_change", "pageTokenChange", "page-token-change":
			return &WatchSecretsResponse_FieldTerminalPath{selector: WatchSecretsResponse_FieldPathSelectorPageTokenChange}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchSecretsResponse_FieldTerminalPath{selector: WatchSecretsResponse_FieldPathSelectorResumeToken}, nil
		case "snapshot_size", "snapshotSize", "snapshot-size":
			return &WatchSecretsResponse_FieldTerminalPath{selector: WatchSecretsResponse_FieldPathSelectorSnapshotSize}, nil
		case "is_soft_reset", "isSoftReset", "is-soft-reset":
			return &WatchSecretsResponse_FieldTerminalPath{selector: WatchSecretsResponse_FieldPathSelectorIsSoftReset}, nil
		case "is_hard_reset", "isHardReset", "is-hard-reset":
			return &WatchSecretsResponse_FieldTerminalPath{selector: WatchSecretsResponse_FieldPathSelectorIsHardReset}, nil
		}
	} else {
		switch fp[0] {
		case "page_token_change", "pageTokenChange", "page-token-change":
			if subpath, err := BuildWatchSecretsResponsePageTokenChange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &WatchSecretsResponse_FieldSubPath{selector: WatchSecretsResponse_FieldPathSelectorPageTokenChange, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchSecretsResponse", fp)
}

func ParseWatchSecretsResponse_FieldPath(rawField string) (WatchSecretsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchSecretsResponse_FieldPath(fp)
}

func MustParseWatchSecretsResponse_FieldPath(rawField string) WatchSecretsResponse_FieldPath {
	fp, err := ParseWatchSecretsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchSecretsResponse_FieldTerminalPath struct {
	selector WatchSecretsResponse_FieldPathSelector
}

var _ WatchSecretsResponse_FieldPath = (*WatchSecretsResponse_FieldTerminalPath)(nil)

func (fp *WatchSecretsResponse_FieldTerminalPath) Selector() WatchSecretsResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchSecretsResponse
func (fp *WatchSecretsResponse_FieldTerminalPath) Get(source *WatchSecretsResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchSecretsResponse_FieldPathSelectorSecretChanges:
			for _, value := range source.GetSecretChanges() {
				values = append(values, value)
			}
		case WatchSecretsResponse_FieldPathSelectorIsCurrent:
			values = append(values, source.IsCurrent)
		case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
			if source.PageTokenChange != nil {
				values = append(values, source.PageTokenChange)
			}
		case WatchSecretsResponse_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchSecretsResponse_FieldPathSelectorSnapshotSize:
			values = append(values, source.SnapshotSize)
		case WatchSecretsResponse_FieldPathSelectorIsSoftReset:
			values = append(values, source.IsSoftReset)
		case WatchSecretsResponse_FieldPathSelectorIsHardReset:
			values = append(values, source.IsHardReset)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchSecretsResponse
func (fp *WatchSecretsResponse_FieldTerminalPath) GetSingle(source *WatchSecretsResponse) (interface{}, bool) {
	switch fp.selector {
	case WatchSecretsResponse_FieldPathSelectorSecretChanges:
		res := source.GetSecretChanges()
		return res, res != nil
	case WatchSecretsResponse_FieldPathSelectorIsCurrent:
		return source.GetIsCurrent(), source != nil
	case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
		res := source.GetPageTokenChange()
		return res, res != nil
	case WatchSecretsResponse_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchSecretsResponse_FieldPathSelectorSnapshotSize:
		return source.GetSnapshotSize(), source != nil
	case WatchSecretsResponse_FieldPathSelectorIsSoftReset:
		return source.GetIsSoftReset(), source != nil
	case WatchSecretsResponse_FieldPathSelectorIsHardReset:
		return source.GetIsHardReset(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchSecretsResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchSecretsResponse_FieldPathSelectorSecretChanges:
		return ([]*secret.SecretChange)(nil)
	case WatchSecretsResponse_FieldPathSelectorIsCurrent:
		return false
	case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
		return (*WatchSecretsResponse_PageTokenChange)(nil)
	case WatchSecretsResponse_FieldPathSelectorResumeToken:
		return ""
	case WatchSecretsResponse_FieldPathSelectorSnapshotSize:
		return int64(0)
	case WatchSecretsResponse_FieldPathSelectorIsSoftReset:
		return false
	case WatchSecretsResponse_FieldPathSelectorIsHardReset:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", fp.selector))
	}
}

func (fp *WatchSecretsResponse_FieldTerminalPath) ClearValue(item *WatchSecretsResponse) {
	if item != nil {
		switch fp.selector {
		case WatchSecretsResponse_FieldPathSelectorSecretChanges:
			item.SecretChanges = nil
		case WatchSecretsResponse_FieldPathSelectorIsCurrent:
			item.IsCurrent = false
		case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
			item.PageTokenChange = nil
		case WatchSecretsResponse_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchSecretsResponse_FieldPathSelectorSnapshotSize:
			item.SnapshotSize = int64(0)
		case WatchSecretsResponse_FieldPathSelectorIsSoftReset:
			item.IsSoftReset = false
		case WatchSecretsResponse_FieldPathSelectorIsHardReset:
			item.IsHardReset = false
		default:
			panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchSecretsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchSecretsResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchSecretsResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchSecretsResponse_FieldPathSelectorSecretChanges ||
		fp.selector == WatchSecretsResponse_FieldPathSelectorIsCurrent ||
		fp.selector == WatchSecretsResponse_FieldPathSelectorResumeToken ||
		fp.selector == WatchSecretsResponse_FieldPathSelectorSnapshotSize ||
		fp.selector == WatchSecretsResponse_FieldPathSelectorIsSoftReset ||
		fp.selector == WatchSecretsResponse_FieldPathSelectorIsHardReset
}

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

func (fp *WatchSecretsResponse_FieldTerminalPath) WithIValue(value interface{}) WatchSecretsResponse_FieldPathValue {
	switch fp.selector {
	case WatchSecretsResponse_FieldPathSelectorSecretChanges:
		return &WatchSecretsResponse_FieldTerminalPathValue{WatchSecretsResponse_FieldTerminalPath: *fp, value: value.([]*secret.SecretChange)}
	case WatchSecretsResponse_FieldPathSelectorIsCurrent:
		return &WatchSecretsResponse_FieldTerminalPathValue{WatchSecretsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
		return &WatchSecretsResponse_FieldTerminalPathValue{WatchSecretsResponse_FieldTerminalPath: *fp, value: value.(*WatchSecretsResponse_PageTokenChange)}
	case WatchSecretsResponse_FieldPathSelectorResumeToken:
		return &WatchSecretsResponse_FieldTerminalPathValue{WatchSecretsResponse_FieldTerminalPath: *fp, value: value.(string)}
	case WatchSecretsResponse_FieldPathSelectorSnapshotSize:
		return &WatchSecretsResponse_FieldTerminalPathValue{WatchSecretsResponse_FieldTerminalPath: *fp, value: value.(int64)}
	case WatchSecretsResponse_FieldPathSelectorIsSoftReset:
		return &WatchSecretsResponse_FieldTerminalPathValue{WatchSecretsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchSecretsResponse_FieldPathSelectorIsHardReset:
		return &WatchSecretsResponse_FieldTerminalPathValue{WatchSecretsResponse_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", fp.selector))
	}
}

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

func (fp *WatchSecretsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchSecretsResponse_FieldPathArrayOfValues {
	fpaov := &WatchSecretsResponse_FieldTerminalPathArrayOfValues{WatchSecretsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchSecretsResponse_FieldPathSelectorSecretChanges:
		return &WatchSecretsResponse_FieldTerminalPathArrayOfValues{WatchSecretsResponse_FieldTerminalPath: *fp, values: values.([][]*secret.SecretChange)}
	case WatchSecretsResponse_FieldPathSelectorIsCurrent:
		return &WatchSecretsResponse_FieldTerminalPathArrayOfValues{WatchSecretsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
		return &WatchSecretsResponse_FieldTerminalPathArrayOfValues{WatchSecretsResponse_FieldTerminalPath: *fp, values: values.([]*WatchSecretsResponse_PageTokenChange)}
	case WatchSecretsResponse_FieldPathSelectorResumeToken:
		return &WatchSecretsResponse_FieldTerminalPathArrayOfValues{WatchSecretsResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchSecretsResponse_FieldPathSelectorSnapshotSize:
		return &WatchSecretsResponse_FieldTerminalPathArrayOfValues{WatchSecretsResponse_FieldTerminalPath: *fp, values: values.([]int64)}
	case WatchSecretsResponse_FieldPathSelectorIsSoftReset:
		return &WatchSecretsResponse_FieldTerminalPathArrayOfValues{WatchSecretsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchSecretsResponse_FieldPathSelectorIsHardReset:
		return &WatchSecretsResponse_FieldTerminalPathArrayOfValues{WatchSecretsResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *WatchSecretsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchSecretsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case WatchSecretsResponse_FieldPathSelectorSecretChanges:
		return &WatchSecretsResponse_FieldTerminalPathArrayItemValue{WatchSecretsResponse_FieldTerminalPath: *fp, value: value.(*secret.SecretChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", fp.selector))
	}
}

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

type WatchSecretsResponse_FieldSubPath struct {
	selector WatchSecretsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ WatchSecretsResponse_FieldPath = (*WatchSecretsResponse_FieldSubPath)(nil)

func (fps *WatchSecretsResponse_FieldSubPath) Selector() WatchSecretsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *WatchSecretsResponse_FieldSubPath) AsPageTokenChangeSubPath() (WatchSecretsResponsePageTokenChange_FieldPath, bool) {
	res, ok := fps.subPath.(WatchSecretsResponsePageTokenChange_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *WatchSecretsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*WatchSecretsResponse))
}

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

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

func (fps *WatchSecretsResponse_FieldSubPath) WithIValue(value interface{}) WatchSecretsResponse_FieldPathValue {
	return &WatchSecretsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *WatchSecretsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) WatchSecretsResponse_FieldPathArrayOfValues {
	return &WatchSecretsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *WatchSecretsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) WatchSecretsResponse_FieldPathArrayItemValue {
	return &WatchSecretsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseWatchSecretsResponse_FieldPathValue(pathStr, valueStr string) WatchSecretsResponse_FieldPathValue {
	fpv, err := ParseWatchSecretsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchSecretsResponse_FieldTerminalPathValue struct {
	WatchSecretsResponse_FieldTerminalPath
	value interface{}
}

var _ WatchSecretsResponse_FieldPathValue = (*WatchSecretsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchSecretsResponse' as interface{}
func (fpv *WatchSecretsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchSecretsResponse_FieldTerminalPathValue) AsSecretChangesValue() ([]*secret.SecretChange, bool) {
	res, ok := fpv.value.([]*secret.SecretChange)
	return res, ok
}
func (fpv *WatchSecretsResponse_FieldTerminalPathValue) AsIsCurrentValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchSecretsResponse_FieldTerminalPathValue) AsPageTokenChangeValue() (*WatchSecretsResponse_PageTokenChange, bool) {
	res, ok := fpv.value.(*WatchSecretsResponse_PageTokenChange)
	return res, ok
}
func (fpv *WatchSecretsResponse_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchSecretsResponse_FieldTerminalPathValue) AsSnapshotSizeValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *WatchSecretsResponse_FieldTerminalPathValue) AsIsSoftResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchSecretsResponse_FieldTerminalPathValue) AsIsHardResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object WatchSecretsResponse
func (fpv *WatchSecretsResponse_FieldTerminalPathValue) SetTo(target **WatchSecretsResponse) {
	if *target == nil {
		*target = new(WatchSecretsResponse)
	}
	switch fpv.selector {
	case WatchSecretsResponse_FieldPathSelectorSecretChanges:
		(*target).SecretChanges = fpv.value.([]*secret.SecretChange)
	case WatchSecretsResponse_FieldPathSelectorIsCurrent:
		(*target).IsCurrent = fpv.value.(bool)
	case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
		(*target).PageTokenChange = fpv.value.(*WatchSecretsResponse_PageTokenChange)
	case WatchSecretsResponse_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchSecretsResponse_FieldPathSelectorSnapshotSize:
		(*target).SnapshotSize = fpv.value.(int64)
	case WatchSecretsResponse_FieldPathSelectorIsSoftReset:
		(*target).IsSoftReset = fpv.value.(bool)
	case WatchSecretsResponse_FieldPathSelectorIsHardReset:
		(*target).IsHardReset = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", fpv.selector))
	}
}

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

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

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

type WatchSecretsResponse_FieldSubPathValue struct {
	WatchSecretsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ WatchSecretsResponse_FieldPathValue = (*WatchSecretsResponse_FieldSubPathValue)(nil)

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

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

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

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

func (fpvs *WatchSecretsResponse_FieldSubPathValue) CompareWith(source *WatchSecretsResponse) (int, bool) {
	switch fpvs.Selector() {
	case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
		return fpvs.subPathValue.(WatchSecretsResponsePageTokenChange_FieldPathValue).CompareWith(source.GetPageTokenChange())
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseWatchSecretsResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchSecretsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchSecretsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchSecretsResponse_FieldTerminalPathArrayItemValue struct {
	WatchSecretsResponse_FieldTerminalPath
	value interface{}
}

var _ WatchSecretsResponse_FieldPathArrayItemValue = (*WatchSecretsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchSecretsResponse as interface{}
func (fpaiv *WatchSecretsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *WatchSecretsResponse_FieldTerminalPathArrayItemValue) AsSecretChangesItemValue() (*secret.SecretChange, bool) {
	res, ok := fpaiv.value.(*secret.SecretChange)
	return res, ok
}

func (fpaiv *WatchSecretsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchSecretsResponse) (interface{}, bool) {
	return nil, false
}

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

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

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

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

// WatchSecretsResponse_FieldPathArrayOfValues allows storing slice of values for WatchSecretsResponse fields according to their type
type WatchSecretsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchSecretsResponse_FieldPath
}

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

func MustParseWatchSecretsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchSecretsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchSecretsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchSecretsResponse_FieldTerminalPathArrayOfValues struct {
	WatchSecretsResponse_FieldTerminalPath
	values interface{}
}

var _ WatchSecretsResponse_FieldPathArrayOfValues = (*WatchSecretsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchSecretsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchSecretsResponse_FieldPathSelectorSecretChanges:
		for _, v := range fpaov.values.([][]*secret.SecretChange) {
			values = append(values, v)
		}
	case WatchSecretsResponse_FieldPathSelectorIsCurrent:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchSecretsResponse_FieldPathSelectorPageTokenChange:
		for _, v := range fpaov.values.([]*WatchSecretsResponse_PageTokenChange) {
			values = append(values, v)
		}
	case WatchSecretsResponse_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchSecretsResponse_FieldPathSelectorSnapshotSize:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case WatchSecretsResponse_FieldPathSelectorIsSoftReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchSecretsResponse_FieldPathSelectorIsHardReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchSecretsResponse_FieldTerminalPathArrayOfValues) AsSecretChangesArrayOfValues() ([][]*secret.SecretChange, bool) {
	res, ok := fpaov.values.([][]*secret.SecretChange)
	return res, ok
}
func (fpaov *WatchSecretsResponse_FieldTerminalPathArrayOfValues) AsIsCurrentArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchSecretsResponse_FieldTerminalPathArrayOfValues) AsPageTokenChangeArrayOfValues() ([]*WatchSecretsResponse_PageTokenChange, bool) {
	res, ok := fpaov.values.([]*WatchSecretsResponse_PageTokenChange)
	return res, ok
}
func (fpaov *WatchSecretsResponse_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchSecretsResponse_FieldTerminalPathArrayOfValues) AsSnapshotSizeArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *WatchSecretsResponse_FieldTerminalPathArrayOfValues) AsIsSoftResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchSecretsResponse_FieldTerminalPathArrayOfValues) AsIsHardResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type WatchSecretsResponse_FieldSubPathArrayOfValues struct {
	WatchSecretsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ WatchSecretsResponse_FieldPathArrayOfValues = (*WatchSecretsResponse_FieldSubPathArrayOfValues)(nil)

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

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

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

type WatchSecretsResponsePageTokenChange_FieldPathSelector int32

const (
	WatchSecretsResponsePageTokenChange_FieldPathSelectorPrevPageToken WatchSecretsResponsePageTokenChange_FieldPathSelector = 0
	WatchSecretsResponsePageTokenChange_FieldPathSelectorNextPageToken WatchSecretsResponsePageTokenChange_FieldPathSelector = 1
)

func (s WatchSecretsResponsePageTokenChange_FieldPathSelector) String() string {
	switch s {
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return "next_page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse_PageTokenChange: %d", s))
	}
}

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

func ParseWatchSecretsResponsePageTokenChange_FieldPath(rawField string) (WatchSecretsResponsePageTokenChange_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchSecretsResponsePageTokenChange_FieldPath(fp)
}

func MustParseWatchSecretsResponsePageTokenChange_FieldPath(rawField string) WatchSecretsResponsePageTokenChange_FieldPath {
	fp, err := ParseWatchSecretsResponsePageTokenChange_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchSecretsResponsePageTokenChange_FieldTerminalPath struct {
	selector WatchSecretsResponsePageTokenChange_FieldPathSelector
}

var _ WatchSecretsResponsePageTokenChange_FieldPath = (*WatchSecretsResponsePageTokenChange_FieldTerminalPath)(nil)

func (fp *WatchSecretsResponsePageTokenChange_FieldTerminalPath) Selector() WatchSecretsResponsePageTokenChange_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchSecretsResponsePageTokenChange_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return (*secret.PagerCursor)(nil)
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return (*secret.PagerCursor)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchSecretsResponsePageTokenChange_FieldTerminalPath) ClearValue(item *WatchSecretsResponse_PageTokenChange) {
	if item != nil {
		switch fp.selector {
		case WatchSecretsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case WatchSecretsResponsePageTokenChange_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse_PageTokenChange: %d", fp.selector))
		}
	}
}

func (fp *WatchSecretsResponsePageTokenChange_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchSecretsResponse_PageTokenChange))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchSecretsResponsePageTokenChange_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchSecretsResponsePageTokenChange_FieldPathSelectorPrevPageToken ||
		fp.selector == WatchSecretsResponsePageTokenChange_FieldPathSelectorNextPageToken
}

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

func (fp *WatchSecretsResponsePageTokenChange_FieldTerminalPath) WithIValue(value interface{}) WatchSecretsResponsePageTokenChange_FieldPathValue {
	switch fp.selector {
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchSecretsResponsePageTokenChange_FieldTerminalPathValue{WatchSecretsResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*secret.PagerCursor)}
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchSecretsResponsePageTokenChange_FieldTerminalPathValue{WatchSecretsResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*secret.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse_PageTokenChange: %d", fp.selector))
	}
}

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

func (fp *WatchSecretsResponsePageTokenChange_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchSecretsResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov := &WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchSecretsResponsePageTokenChange_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchSecretsResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*secret.PagerCursor)}
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchSecretsResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*secret.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse_PageTokenChange: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchSecretsResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) WatchSecretsResponsePageTokenChange_FieldPathValue {
	fpv, err := ParseWatchSecretsResponsePageTokenChange_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchSecretsResponsePageTokenChange_FieldTerminalPathValue struct {
	WatchSecretsResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchSecretsResponsePageTokenChange_FieldPathValue = (*WatchSecretsResponsePageTokenChange_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object PageTokenChange
func (fpv *WatchSecretsResponsePageTokenChange_FieldTerminalPathValue) SetTo(target **WatchSecretsResponse_PageTokenChange) {
	if *target == nil {
		*target = new(WatchSecretsResponse_PageTokenChange)
	}
	switch fpv.selector {
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*secret.PagerCursor)
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*secret.PagerCursor)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchSecretsResponse_PageTokenChange: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseWatchSecretsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) WatchSecretsResponsePageTokenChange_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchSecretsResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayItemValue struct {
	WatchSecretsResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchSecretsResponsePageTokenChange_FieldPathArrayItemValue = (*WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayItemValue) GetSingle(source *WatchSecretsResponse_PageTokenChange) (interface{}, bool) {
	return nil, false
}

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

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

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

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

func MustParseWatchSecretsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) WatchSecretsResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov, err := ParseWatchSecretsResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayOfValues struct {
	WatchSecretsResponsePageTokenChange_FieldTerminalPath
	values interface{}
}

var _ WatchSecretsResponsePageTokenChange_FieldPathArrayOfValues = (*WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*secret.PagerCursor) {
			values = append(values, v)
		}
	case WatchSecretsResponsePageTokenChange_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*secret.PagerCursor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*secret.PagerCursor, bool) {
	res, ok := fpaov.values.([]*secret.PagerCursor)
	return res, ok
}
func (fpaov *WatchSecretsResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*secret.PagerCursor, bool) {
	res, ok := fpaov.values.([]*secret.PagerCursor)
	return res, ok
}

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

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

type CreateSecretRequest_FieldPathSelector int32

const (
	CreateSecretRequest_FieldPathSelectorParent CreateSecretRequest_FieldPathSelector = 0
	CreateSecretRequest_FieldPathSelectorSecret CreateSecretRequest_FieldPathSelector = 1
)

func (s CreateSecretRequest_FieldPathSelector) String() string {
	switch s {
	case CreateSecretRequest_FieldPathSelectorParent:
		return "parent"
	case CreateSecretRequest_FieldPathSelectorSecret:
		return "secret"
	default:
		panic(fmt.Sprintf("Invalid selector for CreateSecretRequest: %d", s))
	}
}

func BuildCreateSecretRequest_FieldPath(fp gotenobject.RawFieldPath) (CreateSecretRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreateSecretRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &CreateSecretRequest_FieldTerminalPath{selector: CreateSecretRequest_FieldPathSelectorParent}, nil
		case "secret":
			return &CreateSecretRequest_FieldTerminalPath{selector: CreateSecretRequest_FieldPathSelectorSecret}, nil
		}
	} else {
		switch fp[0] {
		case "secret":
			if subpath, err := secret.BuildSecret_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateSecretRequest_FieldSubPath{selector: CreateSecretRequest_FieldPathSelectorSecret, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreateSecretRequest", fp)
}

func ParseCreateSecretRequest_FieldPath(rawField string) (CreateSecretRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreateSecretRequest_FieldPath(fp)
}

func MustParseCreateSecretRequest_FieldPath(rawField string) CreateSecretRequest_FieldPath {
	fp, err := ParseCreateSecretRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreateSecretRequest_FieldTerminalPath struct {
	selector CreateSecretRequest_FieldPathSelector
}

var _ CreateSecretRequest_FieldPath = (*CreateSecretRequest_FieldTerminalPath)(nil)

func (fp *CreateSecretRequest_FieldTerminalPath) Selector() CreateSecretRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *CreateSecretRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreateSecretRequest_FieldPathSelectorParent:
		return (*secret.ParentReference)(nil)
	case CreateSecretRequest_FieldPathSelectorSecret:
		return (*secret.Secret)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateSecretRequest: %d", fp.selector))
	}
}

func (fp *CreateSecretRequest_FieldTerminalPath) ClearValue(item *CreateSecretRequest) {
	if item != nil {
		switch fp.selector {
		case CreateSecretRequest_FieldPathSelectorParent:
			item.Parent = nil
		case CreateSecretRequest_FieldPathSelectorSecret:
			item.Secret = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreateSecretRequest: %d", fp.selector))
		}
	}
}

func (fp *CreateSecretRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreateSecretRequest))
}

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

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

func (fp *CreateSecretRequest_FieldTerminalPath) WithIValue(value interface{}) CreateSecretRequest_FieldPathValue {
	switch fp.selector {
	case CreateSecretRequest_FieldPathSelectorParent:
		return &CreateSecretRequest_FieldTerminalPathValue{CreateSecretRequest_FieldTerminalPath: *fp, value: value.(*secret.ParentReference)}
	case CreateSecretRequest_FieldPathSelectorSecret:
		return &CreateSecretRequest_FieldTerminalPathValue{CreateSecretRequest_FieldTerminalPath: *fp, value: value.(*secret.Secret)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateSecretRequest: %d", fp.selector))
	}
}

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

func (fp *CreateSecretRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreateSecretRequest_FieldPathArrayOfValues {
	fpaov := &CreateSecretRequest_FieldTerminalPathArrayOfValues{CreateSecretRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreateSecretRequest_FieldPathSelectorParent:
		return &CreateSecretRequest_FieldTerminalPathArrayOfValues{CreateSecretRequest_FieldTerminalPath: *fp, values: values.([]*secret.ParentReference)}
	case CreateSecretRequest_FieldPathSelectorSecret:
		return &CreateSecretRequest_FieldTerminalPathArrayOfValues{CreateSecretRequest_FieldTerminalPath: *fp, values: values.([]*secret.Secret)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateSecretRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type CreateSecretRequest_FieldSubPath struct {
	selector CreateSecretRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreateSecretRequest_FieldPath = (*CreateSecretRequest_FieldSubPath)(nil)

func (fps *CreateSecretRequest_FieldSubPath) Selector() CreateSecretRequest_FieldPathSelector {
	return fps.selector
}
func (fps *CreateSecretRequest_FieldSubPath) AsSecretSubPath() (secret.Secret_FieldPath, bool) {
	res, ok := fps.subPath.(secret.Secret_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *CreateSecretRequest_FieldSubPath) ClearValue(item *CreateSecretRequest) {
	if item != nil {
		switch fps.selector {
		case CreateSecretRequest_FieldPathSelectorSecret:
			fps.subPath.ClearValueRaw(item.Secret)
		default:
			panic(fmt.Sprintf("Invalid selector for CreateSecretRequest: %d", fps.selector))
		}
	}
}

func (fps *CreateSecretRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreateSecretRequest))
}

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

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

func (fps *CreateSecretRequest_FieldSubPath) WithIValue(value interface{}) CreateSecretRequest_FieldPathValue {
	return &CreateSecretRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *CreateSecretRequest_FieldSubPath) WithIArrayOfValues(values interface{}) CreateSecretRequest_FieldPathArrayOfValues {
	return &CreateSecretRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *CreateSecretRequest_FieldSubPath) WithIArrayItemValue(value interface{}) CreateSecretRequest_FieldPathArrayItemValue {
	return &CreateSecretRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseCreateSecretRequest_FieldPathValue(pathStr, valueStr string) CreateSecretRequest_FieldPathValue {
	fpv, err := ParseCreateSecretRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreateSecretRequest_FieldTerminalPathValue struct {
	CreateSecretRequest_FieldTerminalPath
	value interface{}
}

var _ CreateSecretRequest_FieldPathValue = (*CreateSecretRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreateSecretRequest' as interface{}
func (fpv *CreateSecretRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreateSecretRequest_FieldTerminalPathValue) AsParentValue() (*secret.ParentReference, bool) {
	res, ok := fpv.value.(*secret.ParentReference)
	return res, ok
}
func (fpv *CreateSecretRequest_FieldTerminalPathValue) AsSecretValue() (*secret.Secret, bool) {
	res, ok := fpv.value.(*secret.Secret)
	return res, ok
}

// SetTo stores value for selected field for object CreateSecretRequest
func (fpv *CreateSecretRequest_FieldTerminalPathValue) SetTo(target **CreateSecretRequest) {
	if *target == nil {
		*target = new(CreateSecretRequest)
	}
	switch fpv.selector {
	case CreateSecretRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*secret.ParentReference)
	case CreateSecretRequest_FieldPathSelectorSecret:
		(*target).Secret = fpv.value.(*secret.Secret)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateSecretRequest: %d", fpv.selector))
	}
}

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

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

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

type CreateSecretRequest_FieldSubPathValue struct {
	CreateSecretRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreateSecretRequest_FieldPathValue = (*CreateSecretRequest_FieldSubPathValue)(nil)

func (fpvs *CreateSecretRequest_FieldSubPathValue) AsSecretPathValue() (secret.Secret_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(secret.Secret_FieldPathValue)
	return res, ok
}

func (fpvs *CreateSecretRequest_FieldSubPathValue) SetTo(target **CreateSecretRequest) {
	if *target == nil {
		*target = new(CreateSecretRequest)
	}
	switch fpvs.Selector() {
	case CreateSecretRequest_FieldPathSelectorSecret:
		fpvs.subPathValue.(secret.Secret_FieldPathValue).SetTo(&(*target).Secret)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateSecretRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *CreateSecretRequest_FieldSubPathValue) CompareWith(source *CreateSecretRequest) (int, bool) {
	switch fpvs.Selector() {
	case CreateSecretRequest_FieldPathSelectorSecret:
		return fpvs.subPathValue.(secret.Secret_FieldPathValue).CompareWith(source.GetSecret())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateSecretRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseCreateSecretRequest_FieldPathArrayItemValue(pathStr, valueStr string) CreateSecretRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseCreateSecretRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreateSecretRequest_FieldTerminalPathArrayItemValue struct {
	CreateSecretRequest_FieldTerminalPath
	value interface{}
}

var _ CreateSecretRequest_FieldPathArrayItemValue = (*CreateSecretRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *CreateSecretRequest_FieldTerminalPathArrayItemValue) GetSingle(source *CreateSecretRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *CreateSecretRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *CreateSecretRequest_FieldSubPathArrayItemValue) AsSecretPathItemValue() (secret.Secret_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(secret.Secret_FieldPathArrayItemValue)
	return res, ok
}

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

// CreateSecretRequest_FieldPathArrayOfValues allows storing slice of values for CreateSecretRequest fields according to their type
type CreateSecretRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreateSecretRequest_FieldPath
}

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

func MustParseCreateSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr string) CreateSecretRequest_FieldPathArrayOfValues {
	fpaov, err := ParseCreateSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreateSecretRequest_FieldTerminalPathArrayOfValues struct {
	CreateSecretRequest_FieldTerminalPath
	values interface{}
}

var _ CreateSecretRequest_FieldPathArrayOfValues = (*CreateSecretRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreateSecretRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreateSecretRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*secret.ParentReference) {
			values = append(values, v)
		}
	case CreateSecretRequest_FieldPathSelectorSecret:
		for _, v := range fpaov.values.([]*secret.Secret) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreateSecretRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*secret.ParentReference, bool) {
	res, ok := fpaov.values.([]*secret.ParentReference)
	return res, ok
}
func (fpaov *CreateSecretRequest_FieldTerminalPathArrayOfValues) AsSecretArrayOfValues() ([]*secret.Secret, bool) {
	res, ok := fpaov.values.([]*secret.Secret)
	return res, ok
}

type CreateSecretRequest_FieldSubPathArrayOfValues struct {
	CreateSecretRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreateSecretRequest_FieldPathArrayOfValues = (*CreateSecretRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *CreateSecretRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *CreateSecretRequest_FieldSubPathArrayOfValues) AsSecretPathArrayOfValues() (secret.Secret_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(secret.Secret_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateSecretRequest_FieldPathSelector int32

const (
	UpdateSecretRequest_FieldPathSelectorSecret       UpdateSecretRequest_FieldPathSelector = 0
	UpdateSecretRequest_FieldPathSelectorUpdateMask   UpdateSecretRequest_FieldPathSelector = 1
	UpdateSecretRequest_FieldPathSelectorCas          UpdateSecretRequest_FieldPathSelector = 2
	UpdateSecretRequest_FieldPathSelectorAllowMissing UpdateSecretRequest_FieldPathSelector = 3
)

func (s UpdateSecretRequest_FieldPathSelector) String() string {
	switch s {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		return "secret"
	case UpdateSecretRequest_FieldPathSelectorUpdateMask:
		return "update_mask"
	case UpdateSecretRequest_FieldPathSelectorCas:
		return "cas"
	case UpdateSecretRequest_FieldPathSelectorAllowMissing:
		return "allow_missing"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", s))
	}
}

func BuildUpdateSecretRequest_FieldPath(fp gotenobject.RawFieldPath) (UpdateSecretRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateSecretRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "secret":
			return &UpdateSecretRequest_FieldTerminalPath{selector: UpdateSecretRequest_FieldPathSelectorSecret}, nil
		case "update_mask", "updateMask", "update-mask":
			return &UpdateSecretRequest_FieldTerminalPath{selector: UpdateSecretRequest_FieldPathSelectorUpdateMask}, nil
		case "cas":
			return &UpdateSecretRequest_FieldTerminalPath{selector: UpdateSecretRequest_FieldPathSelectorCas}, nil
		case "allow_missing", "allowMissing", "allow-missing":
			return &UpdateSecretRequest_FieldTerminalPath{selector: UpdateSecretRequest_FieldPathSelectorAllowMissing}, nil
		}
	} else {
		switch fp[0] {
		case "secret":
			if subpath, err := secret.BuildSecret_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateSecretRequest_FieldSubPath{selector: UpdateSecretRequest_FieldPathSelectorSecret, subPath: subpath}, nil
			}
		case "cas":
			if subpath, err := BuildUpdateSecretRequestCAS_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateSecretRequest_FieldSubPath{selector: UpdateSecretRequest_FieldPathSelectorCas, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateSecretRequest", fp)
}

func ParseUpdateSecretRequest_FieldPath(rawField string) (UpdateSecretRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateSecretRequest_FieldPath(fp)
}

func MustParseUpdateSecretRequest_FieldPath(rawField string) UpdateSecretRequest_FieldPath {
	fp, err := ParseUpdateSecretRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateSecretRequest_FieldTerminalPath struct {
	selector UpdateSecretRequest_FieldPathSelector
}

var _ UpdateSecretRequest_FieldPath = (*UpdateSecretRequest_FieldTerminalPath)(nil)

func (fp *UpdateSecretRequest_FieldTerminalPath) Selector() UpdateSecretRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source UpdateSecretRequest
func (fp *UpdateSecretRequest_FieldTerminalPath) Get(source *UpdateSecretRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case UpdateSecretRequest_FieldPathSelectorSecret:
			if source.Secret != nil {
				values = append(values, source.Secret)
			}
		case UpdateSecretRequest_FieldPathSelectorUpdateMask:
			if source.UpdateMask != nil {
				values = append(values, source.UpdateMask)
			}
		case UpdateSecretRequest_FieldPathSelectorCas:
			if source.Cas != nil {
				values = append(values, source.Cas)
			}
		case UpdateSecretRequest_FieldPathSelectorAllowMissing:
			values = append(values, source.AllowMissing)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source UpdateSecretRequest
func (fp *UpdateSecretRequest_FieldTerminalPath) GetSingle(source *UpdateSecretRequest) (interface{}, bool) {
	switch fp.selector {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		res := source.GetSecret()
		return res, res != nil
	case UpdateSecretRequest_FieldPathSelectorUpdateMask:
		res := source.GetUpdateMask()
		return res, res != nil
	case UpdateSecretRequest_FieldPathSelectorCas:
		res := source.GetCas()
		return res, res != nil
	case UpdateSecretRequest_FieldPathSelectorAllowMissing:
		return source.GetAllowMissing(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *UpdateSecretRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		return (*secret.Secret)(nil)
	case UpdateSecretRequest_FieldPathSelectorUpdateMask:
		return (*secret.Secret_FieldMask)(nil)
	case UpdateSecretRequest_FieldPathSelectorCas:
		return (*UpdateSecretRequest_CAS)(nil)
	case UpdateSecretRequest_FieldPathSelectorAllowMissing:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fp.selector))
	}
}

func (fp *UpdateSecretRequest_FieldTerminalPath) ClearValue(item *UpdateSecretRequest) {
	if item != nil {
		switch fp.selector {
		case UpdateSecretRequest_FieldPathSelectorSecret:
			item.Secret = nil
		case UpdateSecretRequest_FieldPathSelectorUpdateMask:
			item.UpdateMask = nil
		case UpdateSecretRequest_FieldPathSelectorCas:
			item.Cas = nil
		case UpdateSecretRequest_FieldPathSelectorAllowMissing:
			item.AllowMissing = false
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fp.selector))
		}
	}
}

func (fp *UpdateSecretRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateSecretRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *UpdateSecretRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == UpdateSecretRequest_FieldPathSelectorUpdateMask ||
		fp.selector == UpdateSecretRequest_FieldPathSelectorAllowMissing
}

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

func (fp *UpdateSecretRequest_FieldTerminalPath) WithIValue(value interface{}) UpdateSecretRequest_FieldPathValue {
	switch fp.selector {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		return &UpdateSecretRequest_FieldTerminalPathValue{UpdateSecretRequest_FieldTerminalPath: *fp, value: value.(*secret.Secret)}
	case UpdateSecretRequest_FieldPathSelectorUpdateMask:
		return &UpdateSecretRequest_FieldTerminalPathValue{UpdateSecretRequest_FieldTerminalPath: *fp, value: value.(*secret.Secret_FieldMask)}
	case UpdateSecretRequest_FieldPathSelectorCas:
		return &UpdateSecretRequest_FieldTerminalPathValue{UpdateSecretRequest_FieldTerminalPath: *fp, value: value.(*UpdateSecretRequest_CAS)}
	case UpdateSecretRequest_FieldPathSelectorAllowMissing:
		return &UpdateSecretRequest_FieldTerminalPathValue{UpdateSecretRequest_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fp.selector))
	}
}

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

func (fp *UpdateSecretRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateSecretRequest_FieldPathArrayOfValues {
	fpaov := &UpdateSecretRequest_FieldTerminalPathArrayOfValues{UpdateSecretRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		return &UpdateSecretRequest_FieldTerminalPathArrayOfValues{UpdateSecretRequest_FieldTerminalPath: *fp, values: values.([]*secret.Secret)}
	case UpdateSecretRequest_FieldPathSelectorUpdateMask:
		return &UpdateSecretRequest_FieldTerminalPathArrayOfValues{UpdateSecretRequest_FieldTerminalPath: *fp, values: values.([]*secret.Secret_FieldMask)}
	case UpdateSecretRequest_FieldPathSelectorCas:
		return &UpdateSecretRequest_FieldTerminalPathArrayOfValues{UpdateSecretRequest_FieldTerminalPath: *fp, values: values.([]*UpdateSecretRequest_CAS)}
	case UpdateSecretRequest_FieldPathSelectorAllowMissing:
		return &UpdateSecretRequest_FieldTerminalPathArrayOfValues{UpdateSecretRequest_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateSecretRequest_FieldSubPath struct {
	selector UpdateSecretRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateSecretRequest_FieldPath = (*UpdateSecretRequest_FieldSubPath)(nil)

func (fps *UpdateSecretRequest_FieldSubPath) Selector() UpdateSecretRequest_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateSecretRequest_FieldSubPath) AsSecretSubPath() (secret.Secret_FieldPath, bool) {
	res, ok := fps.subPath.(secret.Secret_FieldPath)
	return res, ok
}
func (fps *UpdateSecretRequest_FieldSubPath) AsCasSubPath() (UpdateSecretRequestCAS_FieldPath, bool) {
	res, ok := fps.subPath.(UpdateSecretRequestCAS_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *UpdateSecretRequest_FieldSubPath) ClearValue(item *UpdateSecretRequest) {
	if item != nil {
		switch fps.selector {
		case UpdateSecretRequest_FieldPathSelectorSecret:
			fps.subPath.ClearValueRaw(item.Secret)
		case UpdateSecretRequest_FieldPathSelectorCas:
			fps.subPath.ClearValueRaw(item.Cas)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fps.selector))
		}
	}
}

func (fps *UpdateSecretRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateSecretRequest))
}

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

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

func (fps *UpdateSecretRequest_FieldSubPath) WithIValue(value interface{}) UpdateSecretRequest_FieldPathValue {
	return &UpdateSecretRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateSecretRequest_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateSecretRequest_FieldPathArrayOfValues {
	return &UpdateSecretRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateSecretRequest_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateSecretRequest_FieldPathArrayItemValue {
	return &UpdateSecretRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseUpdateSecretRequest_FieldPathValue(pathStr, valueStr string) UpdateSecretRequest_FieldPathValue {
	fpv, err := ParseUpdateSecretRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateSecretRequest_FieldTerminalPathValue struct {
	UpdateSecretRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateSecretRequest_FieldPathValue = (*UpdateSecretRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'UpdateSecretRequest' as interface{}
func (fpv *UpdateSecretRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateSecretRequest_FieldTerminalPathValue) AsSecretValue() (*secret.Secret, bool) {
	res, ok := fpv.value.(*secret.Secret)
	return res, ok
}
func (fpv *UpdateSecretRequest_FieldTerminalPathValue) AsUpdateMaskValue() (*secret.Secret_FieldMask, bool) {
	res, ok := fpv.value.(*secret.Secret_FieldMask)
	return res, ok
}
func (fpv *UpdateSecretRequest_FieldTerminalPathValue) AsCasValue() (*UpdateSecretRequest_CAS, bool) {
	res, ok := fpv.value.(*UpdateSecretRequest_CAS)
	return res, ok
}
func (fpv *UpdateSecretRequest_FieldTerminalPathValue) AsAllowMissingValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object UpdateSecretRequest
func (fpv *UpdateSecretRequest_FieldTerminalPathValue) SetTo(target **UpdateSecretRequest) {
	if *target == nil {
		*target = new(UpdateSecretRequest)
	}
	switch fpv.selector {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		(*target).Secret = fpv.value.(*secret.Secret)
	case UpdateSecretRequest_FieldPathSelectorUpdateMask:
		(*target).UpdateMask = fpv.value.(*secret.Secret_FieldMask)
	case UpdateSecretRequest_FieldPathSelectorCas:
		(*target).Cas = fpv.value.(*UpdateSecretRequest_CAS)
	case UpdateSecretRequest_FieldPathSelectorAllowMissing:
		(*target).AllowMissing = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fpv.selector))
	}
}

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

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

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

type UpdateSecretRequest_FieldSubPathValue struct {
	UpdateSecretRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateSecretRequest_FieldPathValue = (*UpdateSecretRequest_FieldSubPathValue)(nil)

func (fpvs *UpdateSecretRequest_FieldSubPathValue) AsSecretPathValue() (secret.Secret_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(secret.Secret_FieldPathValue)
	return res, ok
}
func (fpvs *UpdateSecretRequest_FieldSubPathValue) AsCasPathValue() (UpdateSecretRequestCAS_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(UpdateSecretRequestCAS_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateSecretRequest_FieldSubPathValue) SetTo(target **UpdateSecretRequest) {
	if *target == nil {
		*target = new(UpdateSecretRequest)
	}
	switch fpvs.Selector() {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		fpvs.subPathValue.(secret.Secret_FieldPathValue).SetTo(&(*target).Secret)
	case UpdateSecretRequest_FieldPathSelectorCas:
		fpvs.subPathValue.(UpdateSecretRequestCAS_FieldPathValue).SetTo(&(*target).Cas)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateSecretRequest_FieldSubPathValue) CompareWith(source *UpdateSecretRequest) (int, bool) {
	switch fpvs.Selector() {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		return fpvs.subPathValue.(secret.Secret_FieldPathValue).CompareWith(source.GetSecret())
	case UpdateSecretRequest_FieldPathSelectorCas:
		return fpvs.subPathValue.(UpdateSecretRequestCAS_FieldPathValue).CompareWith(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseUpdateSecretRequest_FieldPathArrayItemValue(pathStr, valueStr string) UpdateSecretRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateSecretRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateSecretRequest_FieldTerminalPathArrayItemValue struct {
	UpdateSecretRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateSecretRequest_FieldPathArrayItemValue = (*UpdateSecretRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateSecretRequest_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateSecretRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *UpdateSecretRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdateSecretRequest_FieldSubPathArrayItemValue) AsSecretPathItemValue() (secret.Secret_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(secret.Secret_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *UpdateSecretRequest_FieldSubPathArrayItemValue) AsCasPathItemValue() (UpdateSecretRequestCAS_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(UpdateSecretRequestCAS_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'UpdateSecretRequest'
func (fpaivs *UpdateSecretRequest_FieldSubPathArrayItemValue) ContainsValue(source *UpdateSecretRequest) bool {
	switch fpaivs.Selector() {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		return fpaivs.subPathItemValue.(secret.Secret_FieldPathArrayItemValue).ContainsValue(source.GetSecret())
	case UpdateSecretRequest_FieldPathSelectorCas:
		return fpaivs.subPathItemValue.(UpdateSecretRequestCAS_FieldPathArrayItemValue).ContainsValue(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest: %d", fpaivs.Selector()))
	}
}

// UpdateSecretRequest_FieldPathArrayOfValues allows storing slice of values for UpdateSecretRequest fields according to their type
type UpdateSecretRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdateSecretRequest_FieldPath
}

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

func MustParseUpdateSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateSecretRequest_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateSecretRequest_FieldTerminalPathArrayOfValues struct {
	UpdateSecretRequest_FieldTerminalPath
	values interface{}
}

var _ UpdateSecretRequest_FieldPathArrayOfValues = (*UpdateSecretRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateSecretRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateSecretRequest_FieldPathSelectorSecret:
		for _, v := range fpaov.values.([]*secret.Secret) {
			values = append(values, v)
		}
	case UpdateSecretRequest_FieldPathSelectorUpdateMask:
		for _, v := range fpaov.values.([]*secret.Secret_FieldMask) {
			values = append(values, v)
		}
	case UpdateSecretRequest_FieldPathSelectorCas:
		for _, v := range fpaov.values.([]*UpdateSecretRequest_CAS) {
			values = append(values, v)
		}
	case UpdateSecretRequest_FieldPathSelectorAllowMissing:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateSecretRequest_FieldTerminalPathArrayOfValues) AsSecretArrayOfValues() ([]*secret.Secret, bool) {
	res, ok := fpaov.values.([]*secret.Secret)
	return res, ok
}
func (fpaov *UpdateSecretRequest_FieldTerminalPathArrayOfValues) AsUpdateMaskArrayOfValues() ([]*secret.Secret_FieldMask, bool) {
	res, ok := fpaov.values.([]*secret.Secret_FieldMask)
	return res, ok
}
func (fpaov *UpdateSecretRequest_FieldTerminalPathArrayOfValues) AsCasArrayOfValues() ([]*UpdateSecretRequest_CAS, bool) {
	res, ok := fpaov.values.([]*UpdateSecretRequest_CAS)
	return res, ok
}
func (fpaov *UpdateSecretRequest_FieldTerminalPathArrayOfValues) AsAllowMissingArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type UpdateSecretRequest_FieldSubPathArrayOfValues struct {
	UpdateSecretRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateSecretRequest_FieldPathArrayOfValues = (*UpdateSecretRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateSecretRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateSecretRequest_FieldSubPathArrayOfValues) AsSecretPathArrayOfValues() (secret.Secret_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(secret.Secret_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *UpdateSecretRequest_FieldSubPathArrayOfValues) AsCasPathArrayOfValues() (UpdateSecretRequestCAS_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(UpdateSecretRequestCAS_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateSecretRequestCAS_FieldPathSelector int32

const (
	UpdateSecretRequestCAS_FieldPathSelectorConditionalState UpdateSecretRequestCAS_FieldPathSelector = 0
	UpdateSecretRequestCAS_FieldPathSelectorFieldMask        UpdateSecretRequestCAS_FieldPathSelector = 1
)

func (s UpdateSecretRequestCAS_FieldPathSelector) String() string {
	switch s {
	case UpdateSecretRequestCAS_FieldPathSelectorConditionalState:
		return "conditional_state"
	case UpdateSecretRequestCAS_FieldPathSelectorFieldMask:
		return "field_mask"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest_CAS: %d", s))
	}
}

func BuildUpdateSecretRequestCAS_FieldPath(fp gotenobject.RawFieldPath) (UpdateSecretRequestCAS_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateSecretRequest_CAS")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			return &UpdateSecretRequestCAS_FieldTerminalPath{selector: UpdateSecretRequestCAS_FieldPathSelectorConditionalState}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &UpdateSecretRequestCAS_FieldTerminalPath{selector: UpdateSecretRequestCAS_FieldPathSelectorFieldMask}, nil
		}
	} else {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			if subpath, err := secret.BuildSecret_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateSecretRequestCAS_FieldSubPath{selector: UpdateSecretRequestCAS_FieldPathSelectorConditionalState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateSecretRequest_CAS", fp)
}

func ParseUpdateSecretRequestCAS_FieldPath(rawField string) (UpdateSecretRequestCAS_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateSecretRequestCAS_FieldPath(fp)
}

func MustParseUpdateSecretRequestCAS_FieldPath(rawField string) UpdateSecretRequestCAS_FieldPath {
	fp, err := ParseUpdateSecretRequestCAS_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateSecretRequestCAS_FieldTerminalPath struct {
	selector UpdateSecretRequestCAS_FieldPathSelector
}

var _ UpdateSecretRequestCAS_FieldPath = (*UpdateSecretRequestCAS_FieldTerminalPath)(nil)

func (fp *UpdateSecretRequestCAS_FieldTerminalPath) Selector() UpdateSecretRequestCAS_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *UpdateSecretRequestCAS_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateSecretRequestCAS_FieldPathSelectorConditionalState:
		return (*secret.Secret)(nil)
	case UpdateSecretRequestCAS_FieldPathSelectorFieldMask:
		return (*secret.Secret_FieldMask)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdateSecretRequestCAS_FieldTerminalPath) ClearValue(item *UpdateSecretRequest_CAS) {
	if item != nil {
		switch fp.selector {
		case UpdateSecretRequestCAS_FieldPathSelectorConditionalState:
			item.ConditionalState = nil
		case UpdateSecretRequestCAS_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest_CAS: %d", fp.selector))
		}
	}
}

func (fp *UpdateSecretRequestCAS_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateSecretRequest_CAS))
}

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

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

func (fp *UpdateSecretRequestCAS_FieldTerminalPath) WithIValue(value interface{}) UpdateSecretRequestCAS_FieldPathValue {
	switch fp.selector {
	case UpdateSecretRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateSecretRequestCAS_FieldTerminalPathValue{UpdateSecretRequestCAS_FieldTerminalPath: *fp, value: value.(*secret.Secret)}
	case UpdateSecretRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateSecretRequestCAS_FieldTerminalPathValue{UpdateSecretRequestCAS_FieldTerminalPath: *fp, value: value.(*secret.Secret_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest_CAS: %d", fp.selector))
	}
}

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

func (fp *UpdateSecretRequestCAS_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateSecretRequestCAS_FieldPathArrayOfValues {
	fpaov := &UpdateSecretRequestCAS_FieldTerminalPathArrayOfValues{UpdateSecretRequestCAS_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateSecretRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateSecretRequestCAS_FieldTerminalPathArrayOfValues{UpdateSecretRequestCAS_FieldTerminalPath: *fp, values: values.([]*secret.Secret)}
	case UpdateSecretRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateSecretRequestCAS_FieldTerminalPathArrayOfValues{UpdateSecretRequestCAS_FieldTerminalPath: *fp, values: values.([]*secret.Secret_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest_CAS: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateSecretRequestCAS_FieldSubPath struct {
	selector UpdateSecretRequestCAS_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateSecretRequestCAS_FieldPath = (*UpdateSecretRequestCAS_FieldSubPath)(nil)

func (fps *UpdateSecretRequestCAS_FieldSubPath) Selector() UpdateSecretRequestCAS_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateSecretRequestCAS_FieldSubPath) AsConditionalStateSubPath() (secret.Secret_FieldPath, bool) {
	res, ok := fps.subPath.(secret.Secret_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *UpdateSecretRequestCAS_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateSecretRequest_CAS))
}

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

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

func (fps *UpdateSecretRequestCAS_FieldSubPath) WithIValue(value interface{}) UpdateSecretRequestCAS_FieldPathValue {
	return &UpdateSecretRequestCAS_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateSecretRequestCAS_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateSecretRequestCAS_FieldPathArrayOfValues {
	return &UpdateSecretRequestCAS_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateSecretRequestCAS_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateSecretRequestCAS_FieldPathArrayItemValue {
	return &UpdateSecretRequestCAS_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseUpdateSecretRequestCAS_FieldPathValue(pathStr, valueStr string) UpdateSecretRequestCAS_FieldPathValue {
	fpv, err := ParseUpdateSecretRequestCAS_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateSecretRequestCAS_FieldTerminalPathValue struct {
	UpdateSecretRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateSecretRequestCAS_FieldPathValue = (*UpdateSecretRequestCAS_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CAS' as interface{}
func (fpv *UpdateSecretRequestCAS_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateSecretRequestCAS_FieldTerminalPathValue) AsConditionalStateValue() (*secret.Secret, bool) {
	res, ok := fpv.value.(*secret.Secret)
	return res, ok
}
func (fpv *UpdateSecretRequestCAS_FieldTerminalPathValue) AsFieldMaskValue() (*secret.Secret_FieldMask, bool) {
	res, ok := fpv.value.(*secret.Secret_FieldMask)
	return res, ok
}

// SetTo stores value for selected field for object CAS
func (fpv *UpdateSecretRequestCAS_FieldTerminalPathValue) SetTo(target **UpdateSecretRequest_CAS) {
	if *target == nil {
		*target = new(UpdateSecretRequest_CAS)
	}
	switch fpv.selector {
	case UpdateSecretRequestCAS_FieldPathSelectorConditionalState:
		(*target).ConditionalState = fpv.value.(*secret.Secret)
	case UpdateSecretRequestCAS_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*secret.Secret_FieldMask)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest_CAS: %d", fpv.selector))
	}
}

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

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

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

type UpdateSecretRequestCAS_FieldSubPathValue struct {
	UpdateSecretRequestCAS_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateSecretRequestCAS_FieldPathValue = (*UpdateSecretRequestCAS_FieldSubPathValue)(nil)

func (fpvs *UpdateSecretRequestCAS_FieldSubPathValue) AsConditionalStatePathValue() (secret.Secret_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(secret.Secret_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateSecretRequestCAS_FieldSubPathValue) SetTo(target **UpdateSecretRequest_CAS) {
	if *target == nil {
		*target = new(UpdateSecretRequest_CAS)
	}
	switch fpvs.Selector() {
	case UpdateSecretRequestCAS_FieldPathSelectorConditionalState:
		fpvs.subPathValue.(secret.Secret_FieldPathValue).SetTo(&(*target).ConditionalState)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateSecretRequestCAS_FieldSubPathValue) CompareWith(source *UpdateSecretRequest_CAS) (int, bool) {
	switch fpvs.Selector() {
	case UpdateSecretRequestCAS_FieldPathSelectorConditionalState:
		return fpvs.subPathValue.(secret.Secret_FieldPathValue).CompareWith(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateSecretRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseUpdateSecretRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) UpdateSecretRequestCAS_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateSecretRequestCAS_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateSecretRequestCAS_FieldTerminalPathArrayItemValue struct {
	UpdateSecretRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateSecretRequestCAS_FieldPathArrayItemValue = (*UpdateSecretRequestCAS_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateSecretRequestCAS_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateSecretRequest_CAS) (interface{}, bool) {
	return nil, false
}

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

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

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

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

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

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

func MustParseUpdateSecretRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateSecretRequestCAS_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateSecretRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateSecretRequestCAS_FieldTerminalPathArrayOfValues struct {
	UpdateSecretRequestCAS_FieldTerminalPath
	values interface{}
}

var _ UpdateSecretRequestCAS_FieldPathArrayOfValues = (*UpdateSecretRequestCAS_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateSecretRequestCAS_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateSecretRequestCAS_FieldPathSelectorConditionalState:
		for _, v := range fpaov.values.([]*secret.Secret) {
			values = append(values, v)
		}
	case UpdateSecretRequestCAS_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*secret.Secret_FieldMask) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateSecretRequestCAS_FieldTerminalPathArrayOfValues) AsConditionalStateArrayOfValues() ([]*secret.Secret, bool) {
	res, ok := fpaov.values.([]*secret.Secret)
	return res, ok
}
func (fpaov *UpdateSecretRequestCAS_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*secret.Secret_FieldMask, bool) {
	res, ok := fpaov.values.([]*secret.Secret_FieldMask)
	return res, ok
}

type UpdateSecretRequestCAS_FieldSubPathArrayOfValues struct {
	UpdateSecretRequestCAS_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateSecretRequestCAS_FieldPathArrayOfValues = (*UpdateSecretRequestCAS_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateSecretRequestCAS_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateSecretRequestCAS_FieldSubPathArrayOfValues) AsConditionalStatePathArrayOfValues() (secret.Secret_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(secret.Secret_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeleteSecretRequest_FieldPathSelector int32

const (
	DeleteSecretRequest_FieldPathSelectorName DeleteSecretRequest_FieldPathSelector = 0
)

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

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

func ParseDeleteSecretRequest_FieldPath(rawField string) (DeleteSecretRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeleteSecretRequest_FieldPath(fp)
}

func MustParseDeleteSecretRequest_FieldPath(rawField string) DeleteSecretRequest_FieldPath {
	fp, err := ParseDeleteSecretRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeleteSecretRequest_FieldTerminalPath struct {
	selector DeleteSecretRequest_FieldPathSelector
}

var _ DeleteSecretRequest_FieldPath = (*DeleteSecretRequest_FieldTerminalPath)(nil)

func (fp *DeleteSecretRequest_FieldTerminalPath) Selector() DeleteSecretRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *DeleteSecretRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*DeleteSecretRequest))
}

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

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

func (fp *DeleteSecretRequest_FieldTerminalPath) WithIValue(value interface{}) DeleteSecretRequest_FieldPathValue {
	switch fp.selector {
	case DeleteSecretRequest_FieldPathSelectorName:
		return &DeleteSecretRequest_FieldTerminalPathValue{DeleteSecretRequest_FieldTerminalPath: *fp, value: value.(*secret.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteSecretRequest: %d", fp.selector))
	}
}

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

func (fp *DeleteSecretRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeleteSecretRequest_FieldPathArrayOfValues {
	fpaov := &DeleteSecretRequest_FieldTerminalPathArrayOfValues{DeleteSecretRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeleteSecretRequest_FieldPathSelectorName:
		return &DeleteSecretRequest_FieldTerminalPathArrayOfValues{DeleteSecretRequest_FieldTerminalPath: *fp, values: values.([]*secret.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteSecretRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseDeleteSecretRequest_FieldPathValue(pathStr, valueStr string) DeleteSecretRequest_FieldPathValue {
	fpv, err := ParseDeleteSecretRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeleteSecretRequest_FieldTerminalPathValue struct {
	DeleteSecretRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteSecretRequest_FieldPathValue = (*DeleteSecretRequest_FieldTerminalPathValue)(nil)

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

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

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

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

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

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

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

func MustParseDeleteSecretRequest_FieldPathArrayItemValue(pathStr, valueStr string) DeleteSecretRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseDeleteSecretRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeleteSecretRequest_FieldTerminalPathArrayItemValue struct {
	DeleteSecretRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteSecretRequest_FieldPathArrayItemValue = (*DeleteSecretRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeleteSecretRequest_FieldTerminalPathArrayItemValue) GetSingle(source *DeleteSecretRequest) (interface{}, bool) {
	return nil, false
}

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

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

// DeleteSecretRequest_FieldPathArrayOfValues allows storing slice of values for DeleteSecretRequest fields according to their type
type DeleteSecretRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeleteSecretRequest_FieldPath
}

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

func MustParseDeleteSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr string) DeleteSecretRequest_FieldPathArrayOfValues {
	fpaov, err := ParseDeleteSecretRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeleteSecretRequest_FieldTerminalPathArrayOfValues struct {
	DeleteSecretRequest_FieldTerminalPath
	values interface{}
}

var _ DeleteSecretRequest_FieldPathArrayOfValues = (*DeleteSecretRequest_FieldTerminalPathArrayOfValues)(nil)

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