recovery_store_sharding_info.pb.fieldpath.go

// Code generated by protoc-gen-goten-object
// File: edgelq/monitoring/proto/v4/recovery_store_sharding_info.proto
// DO NOT EDIT!!!

package recovery_store_sharding_info

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"

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

// proto imports
import (
	meta "github.com/cloudwan/goten-sdk/types/meta"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// 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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &durationpb.Duration{}
	_ = &timestamppb.Timestamp{}
	_ = &meta.Meta{}
)

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

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

type RecoveryStoreShardingInfo_FieldPathSelector int32

const (
	RecoveryStoreShardingInfo_FieldPathSelectorName           RecoveryStoreShardingInfo_FieldPathSelector = 0
	RecoveryStoreShardingInfo_FieldPathSelectorMetadata       RecoveryStoreShardingInfo_FieldPathSelector = 1
	RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod RecoveryStoreShardingInfo_FieldPathSelector = 2
	RecoveryStoreShardingInfo_FieldPathSelectorSpec           RecoveryStoreShardingInfo_FieldPathSelector = 3
)

func (s RecoveryStoreShardingInfo_FieldPathSelector) String() string {
	switch s {
	case RecoveryStoreShardingInfo_FieldPathSelectorName:
		return "name"
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		return "metadata"
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		return "validity_period"
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		return "spec"
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", s))
	}
}

func BuildRecoveryStoreShardingInfo_FieldPath(fp gotenobject.RawFieldPath) (RecoveryStoreShardingInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object RecoveryStoreShardingInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &RecoveryStoreShardingInfo_FieldTerminalPath{selector: RecoveryStoreShardingInfo_FieldPathSelectorName}, nil
		case "metadata":
			return &RecoveryStoreShardingInfo_FieldTerminalPath{selector: RecoveryStoreShardingInfo_FieldPathSelectorMetadata}, nil
		case "validity_period", "validityPeriod", "validity-period":
			return &RecoveryStoreShardingInfo_FieldTerminalPath{selector: RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod}, nil
		case "spec":
			return &RecoveryStoreShardingInfo_FieldTerminalPath{selector: RecoveryStoreShardingInfo_FieldPathSelectorSpec}, nil
		}
	} else {
		switch fp[0] {
		case "metadata":
			if subpath, err := meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &RecoveryStoreShardingInfo_FieldSubPath{selector: RecoveryStoreShardingInfo_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		case "validity_period", "validityPeriod", "validity-period":
			if subpath, err := BuildRecoveryStoreShardingInfoValidityPeriod_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &RecoveryStoreShardingInfo_FieldSubPath{selector: RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod, subPath: subpath}, nil
			}
		case "spec":
			if subpath, err := BuildRecoveryStoreShardingInfoShardingSpec_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &RecoveryStoreShardingInfo_FieldSubPath{selector: RecoveryStoreShardingInfo_FieldPathSelectorSpec, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object RecoveryStoreShardingInfo", fp)
}

func ParseRecoveryStoreShardingInfo_FieldPath(rawField string) (RecoveryStoreShardingInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRecoveryStoreShardingInfo_FieldPath(fp)
}

func MustParseRecoveryStoreShardingInfo_FieldPath(rawField string) RecoveryStoreShardingInfo_FieldPath {
	fp, err := ParseRecoveryStoreShardingInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RecoveryStoreShardingInfo_FieldTerminalPath struct {
	selector RecoveryStoreShardingInfo_FieldPathSelector
}

var _ RecoveryStoreShardingInfo_FieldPath = (*RecoveryStoreShardingInfo_FieldTerminalPath)(nil)

func (fp *RecoveryStoreShardingInfo_FieldTerminalPath) Selector() RecoveryStoreShardingInfo_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source RecoveryStoreShardingInfo
func (fp *RecoveryStoreShardingInfo_FieldTerminalPath) Get(source *RecoveryStoreShardingInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case RecoveryStoreShardingInfo_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
			if source.ValidityPeriod != nil {
				values = append(values, source.ValidityPeriod)
			}
		case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
			if source.Spec != nil {
				values = append(values, source.Spec)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source RecoveryStoreShardingInfo
func (fp *RecoveryStoreShardingInfo_FieldTerminalPath) GetSingle(source *RecoveryStoreShardingInfo) (interface{}, bool) {
	switch fp.selector {
	case RecoveryStoreShardingInfo_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		return res, res != nil
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		res := source.GetValidityPeriod()
		return res, res != nil
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		res := source.GetSpec()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *RecoveryStoreShardingInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case RecoveryStoreShardingInfo_FieldPathSelectorName:
		return (*Name)(nil)
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		return (*meta.Meta)(nil)
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		return (*RecoveryStoreShardingInfo_ValidityPeriod)(nil)
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		return (*RecoveryStoreShardingInfo_ShardingSpec)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fp.selector))
	}
}

func (fp *RecoveryStoreShardingInfo_FieldTerminalPath) ClearValue(item *RecoveryStoreShardingInfo) {
	if item != nil {
		switch fp.selector {
		case RecoveryStoreShardingInfo_FieldPathSelectorName:
			item.Name = nil
		case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
			item.Metadata = nil
		case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
			item.ValidityPeriod = nil
		case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
			item.Spec = nil
		default:
			panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fp.selector))
		}
	}
}

func (fp *RecoveryStoreShardingInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RecoveryStoreShardingInfo))
}

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

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

func (fp *RecoveryStoreShardingInfo_FieldTerminalPath) WithIValue(value interface{}) RecoveryStoreShardingInfo_FieldPathValue {
	switch fp.selector {
	case RecoveryStoreShardingInfo_FieldPathSelectorName:
		return &RecoveryStoreShardingInfo_FieldTerminalPathValue{RecoveryStoreShardingInfo_FieldTerminalPath: *fp, value: value.(*Name)}
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		return &RecoveryStoreShardingInfo_FieldTerminalPathValue{RecoveryStoreShardingInfo_FieldTerminalPath: *fp, value: value.(*meta.Meta)}
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		return &RecoveryStoreShardingInfo_FieldTerminalPathValue{RecoveryStoreShardingInfo_FieldTerminalPath: *fp, value: value.(*RecoveryStoreShardingInfo_ValidityPeriod)}
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		return &RecoveryStoreShardingInfo_FieldTerminalPathValue{RecoveryStoreShardingInfo_FieldTerminalPath: *fp, value: value.(*RecoveryStoreShardingInfo_ShardingSpec)}
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fp.selector))
	}
}

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

func (fp *RecoveryStoreShardingInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) RecoveryStoreShardingInfo_FieldPathArrayOfValues {
	fpaov := &RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case RecoveryStoreShardingInfo_FieldPathSelectorName:
		return &RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfo_FieldTerminalPath: *fp, values: values.([]*Name)}
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		return &RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfo_FieldTerminalPath: *fp, values: values.([]*meta.Meta)}
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		return &RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfo_FieldTerminalPath: *fp, values: values.([]*RecoveryStoreShardingInfo_ValidityPeriod)}
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		return &RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfo_FieldTerminalPath: *fp, values: values.([]*RecoveryStoreShardingInfo_ShardingSpec)}
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type RecoveryStoreShardingInfo_FieldSubPath struct {
	selector RecoveryStoreShardingInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ RecoveryStoreShardingInfo_FieldPath = (*RecoveryStoreShardingInfo_FieldSubPath)(nil)

func (fps *RecoveryStoreShardingInfo_FieldSubPath) Selector() RecoveryStoreShardingInfo_FieldPathSelector {
	return fps.selector
}
func (fps *RecoveryStoreShardingInfo_FieldSubPath) AsMetadataSubPath() (meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(meta.Meta_FieldPath)
	return res, ok
}
func (fps *RecoveryStoreShardingInfo_FieldSubPath) AsValidityPeriodSubPath() (RecoveryStoreShardingInfoValidityPeriod_FieldPath, bool) {
	res, ok := fps.subPath.(RecoveryStoreShardingInfoValidityPeriod_FieldPath)
	return res, ok
}
func (fps *RecoveryStoreShardingInfo_FieldSubPath) AsSpecSubPath() (RecoveryStoreShardingInfoShardingSpec_FieldPath, bool) {
	res, ok := fps.subPath.(RecoveryStoreShardingInfoShardingSpec_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source RecoveryStoreShardingInfo
func (fps *RecoveryStoreShardingInfo_FieldSubPath) Get(source *RecoveryStoreShardingInfo) (values []interface{}) {
	switch fps.selector {
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetMetadata())...)
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		values = append(values, fps.subPath.GetRaw(source.GetValidityPeriod())...)
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		values = append(values, fps.subPath.GetRaw(source.GetSpec())...)
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source RecoveryStoreShardingInfo
func (fps *RecoveryStoreShardingInfo_FieldSubPath) GetSingle(source *RecoveryStoreShardingInfo) (interface{}, bool) {
	switch fps.selector {
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		if source.GetMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetadata())
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		if source.GetValidityPeriod() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetValidityPeriod())
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		if source.GetSpec() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetSpec())
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fps.selector))
	}
}

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

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

func (fps *RecoveryStoreShardingInfo_FieldSubPath) ClearValue(item *RecoveryStoreShardingInfo) {
	if item != nil {
		switch fps.selector {
		case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
			fps.subPath.ClearValueRaw(item.ValidityPeriod)
		case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
			fps.subPath.ClearValueRaw(item.Spec)
		default:
			panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fps.selector))
		}
	}
}

func (fps *RecoveryStoreShardingInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*RecoveryStoreShardingInfo))
}

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

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

func (fps *RecoveryStoreShardingInfo_FieldSubPath) WithIValue(value interface{}) RecoveryStoreShardingInfo_FieldPathValue {
	return &RecoveryStoreShardingInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *RecoveryStoreShardingInfo_FieldSubPath) WithIArrayOfValues(values interface{}) RecoveryStoreShardingInfo_FieldPathArrayOfValues {
	return &RecoveryStoreShardingInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *RecoveryStoreShardingInfo_FieldSubPath) WithIArrayItemValue(value interface{}) RecoveryStoreShardingInfo_FieldPathArrayItemValue {
	return &RecoveryStoreShardingInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseRecoveryStoreShardingInfo_FieldPathValue(pathStr, valueStr string) RecoveryStoreShardingInfo_FieldPathValue {
	fpv, err := ParseRecoveryStoreShardingInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RecoveryStoreShardingInfo_FieldTerminalPathValue struct {
	RecoveryStoreShardingInfo_FieldTerminalPath
	value interface{}
}

var _ RecoveryStoreShardingInfo_FieldPathValue = (*RecoveryStoreShardingInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RecoveryStoreShardingInfo' as interface{}
func (fpv *RecoveryStoreShardingInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *RecoveryStoreShardingInfo_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *RecoveryStoreShardingInfo_FieldTerminalPathValue) AsMetadataValue() (*meta.Meta, bool) {
	res, ok := fpv.value.(*meta.Meta)
	return res, ok
}
func (fpv *RecoveryStoreShardingInfo_FieldTerminalPathValue) AsValidityPeriodValue() (*RecoveryStoreShardingInfo_ValidityPeriod, bool) {
	res, ok := fpv.value.(*RecoveryStoreShardingInfo_ValidityPeriod)
	return res, ok
}
func (fpv *RecoveryStoreShardingInfo_FieldTerminalPathValue) AsSpecValue() (*RecoveryStoreShardingInfo_ShardingSpec, bool) {
	res, ok := fpv.value.(*RecoveryStoreShardingInfo_ShardingSpec)
	return res, ok
}

// SetTo stores value for selected field for object RecoveryStoreShardingInfo
func (fpv *RecoveryStoreShardingInfo_FieldTerminalPathValue) SetTo(target **RecoveryStoreShardingInfo) {
	if *target == nil {
		*target = new(RecoveryStoreShardingInfo)
	}
	switch fpv.selector {
	case RecoveryStoreShardingInfo_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*meta.Meta)
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		(*target).ValidityPeriod = fpv.value.(*RecoveryStoreShardingInfo_ValidityPeriod)
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		(*target).Spec = fpv.value.(*RecoveryStoreShardingInfo_ShardingSpec)
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fpv.selector))
	}
}

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

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

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

type RecoveryStoreShardingInfo_FieldSubPathValue struct {
	RecoveryStoreShardingInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ RecoveryStoreShardingInfo_FieldPathValue = (*RecoveryStoreShardingInfo_FieldSubPathValue)(nil)

func (fpvs *RecoveryStoreShardingInfo_FieldSubPathValue) AsMetadataPathValue() (meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(meta.Meta_FieldPathValue)
	return res, ok
}
func (fpvs *RecoveryStoreShardingInfo_FieldSubPathValue) AsValidityPeriodPathValue() (RecoveryStoreShardingInfoValidityPeriod_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(RecoveryStoreShardingInfoValidityPeriod_FieldPathValue)
	return res, ok
}
func (fpvs *RecoveryStoreShardingInfo_FieldSubPathValue) AsSpecPathValue() (RecoveryStoreShardingInfoShardingSpec_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(RecoveryStoreShardingInfoShardingSpec_FieldPathValue)
	return res, ok
}

func (fpvs *RecoveryStoreShardingInfo_FieldSubPathValue) SetTo(target **RecoveryStoreShardingInfo) {
	if *target == nil {
		*target = new(RecoveryStoreShardingInfo)
	}
	switch fpvs.Selector() {
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		fpvs.subPathValue.(meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		fpvs.subPathValue.(RecoveryStoreShardingInfoValidityPeriod_FieldPathValue).SetTo(&(*target).ValidityPeriod)
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		fpvs.subPathValue.(RecoveryStoreShardingInfoShardingSpec_FieldPathValue).SetTo(&(*target).Spec)
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *RecoveryStoreShardingInfo_FieldSubPathValue) CompareWith(source *RecoveryStoreShardingInfo) (int, bool) {
	switch fpvs.Selector() {
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		return fpvs.subPathValue.(RecoveryStoreShardingInfoValidityPeriod_FieldPathValue).CompareWith(source.GetValidityPeriod())
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		return fpvs.subPathValue.(RecoveryStoreShardingInfoShardingSpec_FieldPathValue).CompareWith(source.GetSpec())
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseRecoveryStoreShardingInfo_FieldPathArrayItemValue(pathStr, valueStr string) RecoveryStoreShardingInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseRecoveryStoreShardingInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RecoveryStoreShardingInfo_FieldTerminalPathArrayItemValue struct {
	RecoveryStoreShardingInfo_FieldTerminalPath
	value interface{}
}

var _ RecoveryStoreShardingInfo_FieldPathArrayItemValue = (*RecoveryStoreShardingInfo_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RecoveryStoreShardingInfo_FieldTerminalPathArrayItemValue) GetSingle(source *RecoveryStoreShardingInfo) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *RecoveryStoreShardingInfo_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *RecoveryStoreShardingInfo_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *RecoveryStoreShardingInfo_FieldSubPathArrayItemValue) AsValidityPeriodPathItemValue() (RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *RecoveryStoreShardingInfo_FieldSubPathArrayItemValue) AsSpecPathItemValue() (RecoveryStoreShardingInfoShardingSpec_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(RecoveryStoreShardingInfoShardingSpec_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'RecoveryStoreShardingInfo'
func (fpaivs *RecoveryStoreShardingInfo_FieldSubPathArrayItemValue) ContainsValue(source *RecoveryStoreShardingInfo) bool {
	switch fpaivs.Selector() {
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		return fpaivs.subPathItemValue.(RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayItemValue).ContainsValue(source.GetValidityPeriod())
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		return fpaivs.subPathItemValue.(RecoveryStoreShardingInfoShardingSpec_FieldPathArrayItemValue).ContainsValue(source.GetSpec())
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo: %d", fpaivs.Selector()))
	}
}

// RecoveryStoreShardingInfo_FieldPathArrayOfValues allows storing slice of values for RecoveryStoreShardingInfo fields according to their type
type RecoveryStoreShardingInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RecoveryStoreShardingInfo_FieldPath
}

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

func MustParseRecoveryStoreShardingInfo_FieldPathArrayOfValues(pathStr, valuesStr string) RecoveryStoreShardingInfo_FieldPathArrayOfValues {
	fpaov, err := ParseRecoveryStoreShardingInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues struct {
	RecoveryStoreShardingInfo_FieldTerminalPath
	values interface{}
}

var _ RecoveryStoreShardingInfo_FieldPathArrayOfValues = (*RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case RecoveryStoreShardingInfo_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case RecoveryStoreShardingInfo_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*meta.Meta) {
			values = append(values, v)
		}
	case RecoveryStoreShardingInfo_FieldPathSelectorValidityPeriod:
		for _, v := range fpaov.values.([]*RecoveryStoreShardingInfo_ValidityPeriod) {
			values = append(values, v)
		}
	case RecoveryStoreShardingInfo_FieldPathSelectorSpec:
		for _, v := range fpaov.values.([]*RecoveryStoreShardingInfo_ShardingSpec) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*meta.Meta, bool) {
	res, ok := fpaov.values.([]*meta.Meta)
	return res, ok
}
func (fpaov *RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues) AsValidityPeriodArrayOfValues() ([]*RecoveryStoreShardingInfo_ValidityPeriod, bool) {
	res, ok := fpaov.values.([]*RecoveryStoreShardingInfo_ValidityPeriod)
	return res, ok
}
func (fpaov *RecoveryStoreShardingInfo_FieldTerminalPathArrayOfValues) AsSpecArrayOfValues() ([]*RecoveryStoreShardingInfo_ShardingSpec, bool) {
	res, ok := fpaov.values.([]*RecoveryStoreShardingInfo_ShardingSpec)
	return res, ok
}

type RecoveryStoreShardingInfo_FieldSubPathArrayOfValues struct {
	RecoveryStoreShardingInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ RecoveryStoreShardingInfo_FieldPathArrayOfValues = (*RecoveryStoreShardingInfo_FieldSubPathArrayOfValues)(nil)

func (fpsaov *RecoveryStoreShardingInfo_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *RecoveryStoreShardingInfo_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(meta.Meta_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *RecoveryStoreShardingInfo_FieldSubPathArrayOfValues) AsValidityPeriodPathArrayOfValues() (RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *RecoveryStoreShardingInfo_FieldSubPathArrayOfValues) AsSpecPathArrayOfValues() (RecoveryStoreShardingInfoShardingSpec_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(RecoveryStoreShardingInfoShardingSpec_FieldPathArrayOfValues)
	return res, ok
}

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

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

type RecoveryStoreShardingInfoValidityPeriod_FieldPathSelector int32

const (
	RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime RecoveryStoreShardingInfoValidityPeriod_FieldPathSelector = 0
	RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime   RecoveryStoreShardingInfoValidityPeriod_FieldPathSelector = 1
)

func (s RecoveryStoreShardingInfoValidityPeriod_FieldPathSelector) String() string {
	switch s {
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime:
		return "start_time"
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime:
		return "end_time"
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ValidityPeriod: %d", s))
	}
}

func BuildRecoveryStoreShardingInfoValidityPeriod_FieldPath(fp gotenobject.RawFieldPath) (RecoveryStoreShardingInfoValidityPeriod_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object RecoveryStoreShardingInfo_ValidityPeriod")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "start_time", "startTime", "start-time":
			return &RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath{selector: RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime}, nil
		case "end_time", "endTime", "end-time":
			return &RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath{selector: RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object RecoveryStoreShardingInfo_ValidityPeriod", fp)
}

func ParseRecoveryStoreShardingInfoValidityPeriod_FieldPath(rawField string) (RecoveryStoreShardingInfoValidityPeriod_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRecoveryStoreShardingInfoValidityPeriod_FieldPath(fp)
}

func MustParseRecoveryStoreShardingInfoValidityPeriod_FieldPath(rawField string) RecoveryStoreShardingInfoValidityPeriod_FieldPath {
	fp, err := ParseRecoveryStoreShardingInfoValidityPeriod_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath struct {
	selector RecoveryStoreShardingInfoValidityPeriod_FieldPathSelector
}

var _ RecoveryStoreShardingInfoValidityPeriod_FieldPath = (*RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath)(nil)

func (fp *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath) Selector() RecoveryStoreShardingInfoValidityPeriod_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime:
		return (*timestamppb.Timestamp)(nil)
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime:
		return (*timestamppb.Timestamp)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ValidityPeriod: %d", fp.selector))
	}
}

func (fp *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath) ClearValue(item *RecoveryStoreShardingInfo_ValidityPeriod) {
	if item != nil {
		switch fp.selector {
		case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime:
			item.StartTime = nil
		case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime:
			item.EndTime = nil
		default:
			panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ValidityPeriod: %d", fp.selector))
		}
	}
}

func (fp *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RecoveryStoreShardingInfo_ValidityPeriod))
}

// IsLeaf - whether field path is holds simple value
func (fp *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime ||
		fp.selector == RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime
}

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

func (fp *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath) WithIValue(value interface{}) RecoveryStoreShardingInfoValidityPeriod_FieldPathValue {
	switch fp.selector {
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime:
		return &RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue{RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime:
		return &RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue{RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ValidityPeriod: %d", fp.selector))
	}
}

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

func (fp *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath) WithIArrayOfValues(values interface{}) RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayOfValues {
	fpaov := &RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath: *fp}
	switch fp.selector {
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime:
		return &RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime:
		return &RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ValidityPeriod: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// RecoveryStoreShardingInfoValidityPeriod_FieldPathValue allows storing values for ValidityPeriod fields according to their type
type RecoveryStoreShardingInfoValidityPeriod_FieldPathValue interface {
	RecoveryStoreShardingInfoValidityPeriod_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **RecoveryStoreShardingInfo_ValidityPeriod)
	CompareWith(*RecoveryStoreShardingInfo_ValidityPeriod) (cmp int, comparable bool)
}

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

func MustParseRecoveryStoreShardingInfoValidityPeriod_FieldPathValue(pathStr, valueStr string) RecoveryStoreShardingInfoValidityPeriod_FieldPathValue {
	fpv, err := ParseRecoveryStoreShardingInfoValidityPeriod_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue struct {
	RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath
	value interface{}
}

var _ RecoveryStoreShardingInfoValidityPeriod_FieldPathValue = (*RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ValidityPeriod' as interface{}
func (fpv *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue) AsStartTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue) AsEndTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}

// SetTo stores value for selected field for object ValidityPeriod
func (fpv *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue) SetTo(target **RecoveryStoreShardingInfo_ValidityPeriod) {
	if *target == nil {
		*target = new(RecoveryStoreShardingInfo_ValidityPeriod)
	}
	switch fpv.selector {
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime:
		(*target).StartTime = fpv.value.(*timestamppb.Timestamp)
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime:
		(*target).EndTime = fpv.value.(*timestamppb.Timestamp)
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ValidityPeriod: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue' with the value under path in 'RecoveryStoreShardingInfo_ValidityPeriod'.
func (fpv *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathValue) CompareWith(source *RecoveryStoreShardingInfo_ValidityPeriod) (int, bool) {
	switch fpv.selector {
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetStartTime()
		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 RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetEndTime()
		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
		}
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ValidityPeriod: %d", fpv.selector))
	}
}

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

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

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

func MustParseRecoveryStoreShardingInfoValidityPeriod_FieldPathArrayItemValue(pathStr, valueStr string) RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayItemValue {
	fpaiv, err := ParseRecoveryStoreShardingInfoValidityPeriod_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayItemValue struct {
	RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath
	value interface{}
}

var _ RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayItemValue = (*RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayItemValue) GetSingle(source *RecoveryStoreShardingInfo_ValidityPeriod) (interface{}, bool) {
	return nil, false
}

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

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

// RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayOfValues allows storing slice of values for ValidityPeriod fields according to their type
type RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RecoveryStoreShardingInfoValidityPeriod_FieldPath
}

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

func MustParseRecoveryStoreShardingInfoValidityPeriod_FieldPathArrayOfValues(pathStr, valuesStr string) RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayOfValues {
	fpaov, err := ParseRecoveryStoreShardingInfoValidityPeriod_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayOfValues struct {
	RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPath
	values interface{}
}

var _ RecoveryStoreShardingInfoValidityPeriod_FieldPathArrayOfValues = (*RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorStartTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case RecoveryStoreShardingInfoValidityPeriod_FieldPathSelectorEndTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayOfValues) AsStartTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *RecoveryStoreShardingInfoValidityPeriod_FieldTerminalPathArrayOfValues) AsEndTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}

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

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

type RecoveryStoreShardingInfoShardingSpec_FieldPathSelector int32

const (
	RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod RecoveryStoreShardingInfoShardingSpec_FieldPathSelector = 0
	RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount  RecoveryStoreShardingInfoShardingSpec_FieldPathSelector = 1
)

func (s RecoveryStoreShardingInfoShardingSpec_FieldPathSelector) String() string {
	switch s {
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod:
		return "ts_blob_period"
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount:
		return "shards_count"
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ShardingSpec: %d", s))
	}
}

func BuildRecoveryStoreShardingInfoShardingSpec_FieldPath(fp gotenobject.RawFieldPath) (RecoveryStoreShardingInfoShardingSpec_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object RecoveryStoreShardingInfo_ShardingSpec")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "ts_blob_period", "tsBlobPeriod", "ts-blob-period":
			return &RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath{selector: RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod}, nil
		case "shards_count", "shardsCount", "shards-count":
			return &RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath{selector: RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object RecoveryStoreShardingInfo_ShardingSpec", fp)
}

func ParseRecoveryStoreShardingInfoShardingSpec_FieldPath(rawField string) (RecoveryStoreShardingInfoShardingSpec_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRecoveryStoreShardingInfoShardingSpec_FieldPath(fp)
}

func MustParseRecoveryStoreShardingInfoShardingSpec_FieldPath(rawField string) RecoveryStoreShardingInfoShardingSpec_FieldPath {
	fp, err := ParseRecoveryStoreShardingInfoShardingSpec_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath struct {
	selector RecoveryStoreShardingInfoShardingSpec_FieldPathSelector
}

var _ RecoveryStoreShardingInfoShardingSpec_FieldPath = (*RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath)(nil)

func (fp *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath) Selector() RecoveryStoreShardingInfoShardingSpec_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod:
		return (*durationpb.Duration)(nil)
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount:
		return uint32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ShardingSpec: %d", fp.selector))
	}
}

func (fp *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath) ClearValue(item *RecoveryStoreShardingInfo_ShardingSpec) {
	if item != nil {
		switch fp.selector {
		case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod:
			item.TsBlobPeriod = nil
		case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount:
			item.ShardsCount = uint32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ShardingSpec: %d", fp.selector))
		}
	}
}

func (fp *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RecoveryStoreShardingInfo_ShardingSpec))
}

// IsLeaf - whether field path is holds simple value
func (fp *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod ||
		fp.selector == RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount
}

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

func (fp *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath) WithIValue(value interface{}) RecoveryStoreShardingInfoShardingSpec_FieldPathValue {
	switch fp.selector {
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod:
		return &RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue{RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount:
		return &RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue{RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath: *fp, value: value.(uint32)}
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ShardingSpec: %d", fp.selector))
	}
}

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

func (fp *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) RecoveryStoreShardingInfoShardingSpec_FieldPathArrayOfValues {
	fpaov := &RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath: *fp}
	switch fp.selector {
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod:
		return &RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount:
		return &RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayOfValues{RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath: *fp, values: values.([]uint32)}
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ShardingSpec: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// RecoveryStoreShardingInfoShardingSpec_FieldPathValue allows storing values for ShardingSpec fields according to their type
type RecoveryStoreShardingInfoShardingSpec_FieldPathValue interface {
	RecoveryStoreShardingInfoShardingSpec_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **RecoveryStoreShardingInfo_ShardingSpec)
	CompareWith(*RecoveryStoreShardingInfo_ShardingSpec) (cmp int, comparable bool)
}

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

func MustParseRecoveryStoreShardingInfoShardingSpec_FieldPathValue(pathStr, valueStr string) RecoveryStoreShardingInfoShardingSpec_FieldPathValue {
	fpv, err := ParseRecoveryStoreShardingInfoShardingSpec_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue struct {
	RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath
	value interface{}
}

var _ RecoveryStoreShardingInfoShardingSpec_FieldPathValue = (*RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ShardingSpec' as interface{}
func (fpv *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue) AsTsBlobPeriodValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue) AsShardsCountValue() (uint32, bool) {
	res, ok := fpv.value.(uint32)
	return res, ok
}

// SetTo stores value for selected field for object ShardingSpec
func (fpv *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue) SetTo(target **RecoveryStoreShardingInfo_ShardingSpec) {
	if *target == nil {
		*target = new(RecoveryStoreShardingInfo_ShardingSpec)
	}
	switch fpv.selector {
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod:
		(*target).TsBlobPeriod = fpv.value.(*durationpb.Duration)
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount:
		(*target).ShardsCount = fpv.value.(uint32)
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ShardingSpec: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue' with the value under path in 'RecoveryStoreShardingInfo_ShardingSpec'.
func (fpv *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathValue) CompareWith(source *RecoveryStoreShardingInfo_ShardingSpec) (int, bool) {
	switch fpv.selector {
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetTsBlobPeriod()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount:
		leftValue := fpv.value.(uint32)
		rightValue := source.GetShardsCount()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for RecoveryStoreShardingInfo_ShardingSpec: %d", fpv.selector))
	}
}

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

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

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

func MustParseRecoveryStoreShardingInfoShardingSpec_FieldPathArrayItemValue(pathStr, valueStr string) RecoveryStoreShardingInfoShardingSpec_FieldPathArrayItemValue {
	fpaiv, err := ParseRecoveryStoreShardingInfoShardingSpec_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayItemValue struct {
	RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath
	value interface{}
}

var _ RecoveryStoreShardingInfoShardingSpec_FieldPathArrayItemValue = (*RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayItemValue) GetSingle(source *RecoveryStoreShardingInfo_ShardingSpec) (interface{}, bool) {
	return nil, false
}

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

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

// RecoveryStoreShardingInfoShardingSpec_FieldPathArrayOfValues allows storing slice of values for ShardingSpec fields according to their type
type RecoveryStoreShardingInfoShardingSpec_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RecoveryStoreShardingInfoShardingSpec_FieldPath
}

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

func MustParseRecoveryStoreShardingInfoShardingSpec_FieldPathArrayOfValues(pathStr, valuesStr string) RecoveryStoreShardingInfoShardingSpec_FieldPathArrayOfValues {
	fpaov, err := ParseRecoveryStoreShardingInfoShardingSpec_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayOfValues struct {
	RecoveryStoreShardingInfoShardingSpec_FieldTerminalPath
	values interface{}
}

var _ RecoveryStoreShardingInfoShardingSpec_FieldPathArrayOfValues = (*RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorTsBlobPeriod:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case RecoveryStoreShardingInfoShardingSpec_FieldPathSelectorShardsCount:
		for _, v := range fpaov.values.([]uint32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayOfValues) AsTsBlobPeriodArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *RecoveryStoreShardingInfoShardingSpec_FieldTerminalPathArrayOfValues) AsShardsCountArrayOfValues() ([]uint32, bool) {
	res, ok := fpaov.values.([]uint32)
	return res, ok
}