github.com/cloudwan/edgelq-sdk@v1.15.4/iam/resources/v1/common/common.pb.fieldpath.go

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

package iam_common

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

	"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"
	"github.com/cloudwan/goten-sdk/runtime/strcase"
)

// proto imports
import (
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
)

// 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 (
	_ = &meta_service.Service{}
)

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

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

type PCR_FieldPathSelector int32

const (
	PCR_FieldPathSelectorIndex     PCR_FieldPathSelector = 0
	PCR_FieldPathSelectorDigestHex PCR_FieldPathSelector = 1
	PCR_FieldPathSelectorDigestAlg PCR_FieldPathSelector = 2
	PCR_FieldPathSelectorComment   PCR_FieldPathSelector = 3
)

func (s PCR_FieldPathSelector) String() string {
	switch s {
	case PCR_FieldPathSelectorIndex:
		return "index"
	case PCR_FieldPathSelectorDigestHex:
		return "digest_hex"
	case PCR_FieldPathSelectorDigestAlg:
		return "digest_alg"
	case PCR_FieldPathSelectorComment:
		return "comment"
	default:
		panic(fmt.Sprintf("Invalid selector for PCR: %d", s))
	}
}

func BuildPCR_FieldPath(fp gotenobject.RawFieldPath) (PCR_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PCR")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "index":
			return &PCR_FieldTerminalPath{selector: PCR_FieldPathSelectorIndex}, nil
		case "digest_hex", "digestHex", "digest-hex":
			return &PCR_FieldTerminalPath{selector: PCR_FieldPathSelectorDigestHex}, nil
		case "digest_alg", "digestAlg", "digest-alg":
			return &PCR_FieldTerminalPath{selector: PCR_FieldPathSelectorDigestAlg}, nil
		case "comment":
			return &PCR_FieldTerminalPath{selector: PCR_FieldPathSelectorComment}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PCR", fp)
}

func ParsePCR_FieldPath(rawField string) (PCR_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPCR_FieldPath(fp)
}

func MustParsePCR_FieldPath(rawField string) PCR_FieldPath {
	fp, err := ParsePCR_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PCR_FieldTerminalPath struct {
	selector PCR_FieldPathSelector
}

var _ PCR_FieldPath = (*PCR_FieldTerminalPath)(nil)

func (fp *PCR_FieldTerminalPath) Selector() PCR_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PCR
func (fp *PCR_FieldTerminalPath) Get(source *PCR) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PCR_FieldPathSelectorIndex:
			values = append(values, source.Index)
		case PCR_FieldPathSelectorDigestHex:
			values = append(values, source.DigestHex)
		case PCR_FieldPathSelectorDigestAlg:
			values = append(values, source.DigestAlg)
		case PCR_FieldPathSelectorComment:
			values = append(values, source.Comment)
		default:
			panic(fmt.Sprintf("Invalid selector for PCR: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PCR
func (fp *PCR_FieldTerminalPath) GetSingle(source *PCR) (interface{}, bool) {
	switch fp.selector {
	case PCR_FieldPathSelectorIndex:
		return source.GetIndex(), source != nil
	case PCR_FieldPathSelectorDigestHex:
		return source.GetDigestHex(), source != nil
	case PCR_FieldPathSelectorDigestAlg:
		return source.GetDigestAlg(), source != nil
	case PCR_FieldPathSelectorComment:
		return source.GetComment(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PCR: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PCR_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PCR_FieldPathSelectorIndex:
		return uint32(0)
	case PCR_FieldPathSelectorDigestHex:
		return ""
	case PCR_FieldPathSelectorDigestAlg:
		return DigestAlg_SHA1
	case PCR_FieldPathSelectorComment:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for PCR: %d", fp.selector))
	}
}

func (fp *PCR_FieldTerminalPath) ClearValue(item *PCR) {
	if item != nil {
		switch fp.selector {
		case PCR_FieldPathSelectorIndex:
			item.Index = uint32(0)
		case PCR_FieldPathSelectorDigestHex:
			item.DigestHex = ""
		case PCR_FieldPathSelectorDigestAlg:
			item.DigestAlg = DigestAlg_SHA1
		case PCR_FieldPathSelectorComment:
			item.Comment = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PCR: %d", fp.selector))
		}
	}
}

func (fp *PCR_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PCR))
}

// IsLeaf - whether field path is holds simple value
func (fp *PCR_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PCR_FieldPathSelectorIndex ||
		fp.selector == PCR_FieldPathSelectorDigestHex ||
		fp.selector == PCR_FieldPathSelectorDigestAlg ||
		fp.selector == PCR_FieldPathSelectorComment
}

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

func (fp *PCR_FieldTerminalPath) WithIValue(value interface{}) PCR_FieldPathValue {
	switch fp.selector {
	case PCR_FieldPathSelectorIndex:
		return &PCR_FieldTerminalPathValue{PCR_FieldTerminalPath: *fp, value: value.(uint32)}
	case PCR_FieldPathSelectorDigestHex:
		return &PCR_FieldTerminalPathValue{PCR_FieldTerminalPath: *fp, value: value.(string)}
	case PCR_FieldPathSelectorDigestAlg:
		return &PCR_FieldTerminalPathValue{PCR_FieldTerminalPath: *fp, value: value.(DigestAlg)}
	case PCR_FieldPathSelectorComment:
		return &PCR_FieldTerminalPathValue{PCR_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PCR: %d", fp.selector))
	}
}

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

func (fp *PCR_FieldTerminalPath) WithIArrayOfValues(values interface{}) PCR_FieldPathArrayOfValues {
	fpaov := &PCR_FieldTerminalPathArrayOfValues{PCR_FieldTerminalPath: *fp}
	switch fp.selector {
	case PCR_FieldPathSelectorIndex:
		return &PCR_FieldTerminalPathArrayOfValues{PCR_FieldTerminalPath: *fp, values: values.([]uint32)}
	case PCR_FieldPathSelectorDigestHex:
		return &PCR_FieldTerminalPathArrayOfValues{PCR_FieldTerminalPath: *fp, values: values.([]string)}
	case PCR_FieldPathSelectorDigestAlg:
		return &PCR_FieldTerminalPathArrayOfValues{PCR_FieldTerminalPath: *fp, values: values.([]DigestAlg)}
	case PCR_FieldPathSelectorComment:
		return &PCR_FieldTerminalPathArrayOfValues{PCR_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PCR: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParsePCR_FieldPathValue(pathStr, valueStr string) PCR_FieldPathValue {
	fpv, err := ParsePCR_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PCR_FieldTerminalPathValue struct {
	PCR_FieldTerminalPath
	value interface{}
}

var _ PCR_FieldPathValue = (*PCR_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PCR' as interface{}
func (fpv *PCR_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PCR_FieldTerminalPathValue) AsIndexValue() (uint32, bool) {
	res, ok := fpv.value.(uint32)
	return res, ok
}
func (fpv *PCR_FieldTerminalPathValue) AsDigestHexValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PCR_FieldTerminalPathValue) AsDigestAlgValue() (DigestAlg, bool) {
	res, ok := fpv.value.(DigestAlg)
	return res, ok
}
func (fpv *PCR_FieldTerminalPathValue) AsCommentValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object PCR
func (fpv *PCR_FieldTerminalPathValue) SetTo(target **PCR) {
	if *target == nil {
		*target = new(PCR)
	}
	switch fpv.selector {
	case PCR_FieldPathSelectorIndex:
		(*target).Index = fpv.value.(uint32)
	case PCR_FieldPathSelectorDigestHex:
		(*target).DigestHex = fpv.value.(string)
	case PCR_FieldPathSelectorDigestAlg:
		(*target).DigestAlg = fpv.value.(DigestAlg)
	case PCR_FieldPathSelectorComment:
		(*target).Comment = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PCR: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PCR_FieldTerminalPathValue' with the value under path in 'PCR'.
func (fpv *PCR_FieldTerminalPathValue) CompareWith(source *PCR) (int, bool) {
	switch fpv.selector {
	case PCR_FieldPathSelectorIndex:
		leftValue := fpv.value.(uint32)
		rightValue := source.GetIndex()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PCR_FieldPathSelectorDigestHex:
		leftValue := fpv.value.(string)
		rightValue := source.GetDigestHex()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PCR_FieldPathSelectorDigestAlg:
		leftValue := fpv.value.(DigestAlg)
		rightValue := source.GetDigestAlg()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PCR_FieldPathSelectorComment:
		leftValue := fpv.value.(string)
		rightValue := source.GetComment()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for PCR: %d", fpv.selector))
	}
}

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

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

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

func MustParsePCR_FieldPathArrayItemValue(pathStr, valueStr string) PCR_FieldPathArrayItemValue {
	fpaiv, err := ParsePCR_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PCR_FieldTerminalPathArrayItemValue struct {
	PCR_FieldTerminalPath
	value interface{}
}

var _ PCR_FieldPathArrayItemValue = (*PCR_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PCR_FieldTerminalPathArrayItemValue) GetSingle(source *PCR) (interface{}, bool) {
	return nil, false
}

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

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

// PCR_FieldPathArrayOfValues allows storing slice of values for PCR fields according to their type
type PCR_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PCR_FieldPath
}

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

func MustParsePCR_FieldPathArrayOfValues(pathStr, valuesStr string) PCR_FieldPathArrayOfValues {
	fpaov, err := ParsePCR_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PCR_FieldTerminalPathArrayOfValues struct {
	PCR_FieldTerminalPath
	values interface{}
}

var _ PCR_FieldPathArrayOfValues = (*PCR_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PCR_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PCR_FieldPathSelectorIndex:
		for _, v := range fpaov.values.([]uint32) {
			values = append(values, v)
		}
	case PCR_FieldPathSelectorDigestHex:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PCR_FieldPathSelectorDigestAlg:
		for _, v := range fpaov.values.([]DigestAlg) {
			values = append(values, v)
		}
	case PCR_FieldPathSelectorComment:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PCR_FieldTerminalPathArrayOfValues) AsIndexArrayOfValues() ([]uint32, bool) {
	res, ok := fpaov.values.([]uint32)
	return res, ok
}
func (fpaov *PCR_FieldTerminalPathArrayOfValues) AsDigestHexArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PCR_FieldTerminalPathArrayOfValues) AsDigestAlgArrayOfValues() ([]DigestAlg, bool) {
	res, ok := fpaov.values.([]DigestAlg)
	return res, ok
}
func (fpaov *PCR_FieldTerminalPathArrayOfValues) AsCommentArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type ServiceBusinessTier_FieldPathSelector int32

const (
	ServiceBusinessTier_FieldPathSelectorService      ServiceBusinessTier_FieldPathSelector = 0
	ServiceBusinessTier_FieldPathSelectorBusinessTier ServiceBusinessTier_FieldPathSelector = 1
)

func (s ServiceBusinessTier_FieldPathSelector) String() string {
	switch s {
	case ServiceBusinessTier_FieldPathSelectorService:
		return "service"
	case ServiceBusinessTier_FieldPathSelectorBusinessTier:
		return "business_tier"
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceBusinessTier: %d", s))
	}
}

func BuildServiceBusinessTier_FieldPath(fp gotenobject.RawFieldPath) (ServiceBusinessTier_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ServiceBusinessTier")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service":
			return &ServiceBusinessTier_FieldTerminalPath{selector: ServiceBusinessTier_FieldPathSelectorService}, nil
		case "business_tier", "businessTier", "business-tier":
			return &ServiceBusinessTier_FieldTerminalPath{selector: ServiceBusinessTier_FieldPathSelectorBusinessTier}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ServiceBusinessTier", fp)
}

func ParseServiceBusinessTier_FieldPath(rawField string) (ServiceBusinessTier_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildServiceBusinessTier_FieldPath(fp)
}

func MustParseServiceBusinessTier_FieldPath(rawField string) ServiceBusinessTier_FieldPath {
	fp, err := ParseServiceBusinessTier_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ServiceBusinessTier_FieldTerminalPath struct {
	selector ServiceBusinessTier_FieldPathSelector
}

var _ ServiceBusinessTier_FieldPath = (*ServiceBusinessTier_FieldTerminalPath)(nil)

func (fp *ServiceBusinessTier_FieldTerminalPath) Selector() ServiceBusinessTier_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *ServiceBusinessTier_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ServiceBusinessTier_FieldPathSelectorService:
		return (*meta_service.Name)(nil)
	case ServiceBusinessTier_FieldPathSelectorBusinessTier:
		return BusinessTier_UNDEFINED
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceBusinessTier: %d", fp.selector))
	}
}

func (fp *ServiceBusinessTier_FieldTerminalPath) ClearValue(item *ServiceBusinessTier) {
	if item != nil {
		switch fp.selector {
		case ServiceBusinessTier_FieldPathSelectorService:
			item.Service = nil
		case ServiceBusinessTier_FieldPathSelectorBusinessTier:
			item.BusinessTier = BusinessTier_UNDEFINED
		default:
			panic(fmt.Sprintf("Invalid selector for ServiceBusinessTier: %d", fp.selector))
		}
	}
}

func (fp *ServiceBusinessTier_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ServiceBusinessTier))
}

// IsLeaf - whether field path is holds simple value
func (fp *ServiceBusinessTier_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ServiceBusinessTier_FieldPathSelectorService ||
		fp.selector == ServiceBusinessTier_FieldPathSelectorBusinessTier
}

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

func (fp *ServiceBusinessTier_FieldTerminalPath) WithIValue(value interface{}) ServiceBusinessTier_FieldPathValue {
	switch fp.selector {
	case ServiceBusinessTier_FieldPathSelectorService:
		return &ServiceBusinessTier_FieldTerminalPathValue{ServiceBusinessTier_FieldTerminalPath: *fp, value: value.(*meta_service.Name)}
	case ServiceBusinessTier_FieldPathSelectorBusinessTier:
		return &ServiceBusinessTier_FieldTerminalPathValue{ServiceBusinessTier_FieldTerminalPath: *fp, value: value.(BusinessTier)}
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceBusinessTier: %d", fp.selector))
	}
}

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

func (fp *ServiceBusinessTier_FieldTerminalPath) WithIArrayOfValues(values interface{}) ServiceBusinessTier_FieldPathArrayOfValues {
	fpaov := &ServiceBusinessTier_FieldTerminalPathArrayOfValues{ServiceBusinessTier_FieldTerminalPath: *fp}
	switch fp.selector {
	case ServiceBusinessTier_FieldPathSelectorService:
		return &ServiceBusinessTier_FieldTerminalPathArrayOfValues{ServiceBusinessTier_FieldTerminalPath: *fp, values: values.([]*meta_service.Name)}
	case ServiceBusinessTier_FieldPathSelectorBusinessTier:
		return &ServiceBusinessTier_FieldTerminalPathArrayOfValues{ServiceBusinessTier_FieldTerminalPath: *fp, values: values.([]BusinessTier)}
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceBusinessTier: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseServiceBusinessTier_FieldPathValue(pathStr, valueStr string) ServiceBusinessTier_FieldPathValue {
	fpv, err := ParseServiceBusinessTier_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ServiceBusinessTier_FieldTerminalPathValue struct {
	ServiceBusinessTier_FieldTerminalPath
	value interface{}
}

var _ ServiceBusinessTier_FieldPathValue = (*ServiceBusinessTier_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ServiceBusinessTier' as interface{}
func (fpv *ServiceBusinessTier_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ServiceBusinessTier_FieldTerminalPathValue) AsServiceValue() (*meta_service.Name, bool) {
	res, ok := fpv.value.(*meta_service.Name)
	return res, ok
}
func (fpv *ServiceBusinessTier_FieldTerminalPathValue) AsBusinessTierValue() (BusinessTier, bool) {
	res, ok := fpv.value.(BusinessTier)
	return res, ok
}

// SetTo stores value for selected field for object ServiceBusinessTier
func (fpv *ServiceBusinessTier_FieldTerminalPathValue) SetTo(target **ServiceBusinessTier) {
	if *target == nil {
		*target = new(ServiceBusinessTier)
	}
	switch fpv.selector {
	case ServiceBusinessTier_FieldPathSelectorService:
		(*target).Service = fpv.value.(*meta_service.Name)
	case ServiceBusinessTier_FieldPathSelectorBusinessTier:
		(*target).BusinessTier = fpv.value.(BusinessTier)
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceBusinessTier: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ServiceBusinessTier_FieldTerminalPathValue' with the value under path in 'ServiceBusinessTier'.
func (fpv *ServiceBusinessTier_FieldTerminalPathValue) CompareWith(source *ServiceBusinessTier) (int, bool) {
	switch fpv.selector {
	case ServiceBusinessTier_FieldPathSelectorService:
		leftValue := fpv.value.(*meta_service.Name)
		rightValue := source.GetService()
		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 ServiceBusinessTier_FieldPathSelectorBusinessTier:
		leftValue := fpv.value.(BusinessTier)
		rightValue := source.GetBusinessTier()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceBusinessTier: %d", fpv.selector))
	}
}

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

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

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

func MustParseServiceBusinessTier_FieldPathArrayItemValue(pathStr, valueStr string) ServiceBusinessTier_FieldPathArrayItemValue {
	fpaiv, err := ParseServiceBusinessTier_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ServiceBusinessTier_FieldTerminalPathArrayItemValue struct {
	ServiceBusinessTier_FieldTerminalPath
	value interface{}
}

var _ ServiceBusinessTier_FieldPathArrayItemValue = (*ServiceBusinessTier_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ServiceBusinessTier_FieldTerminalPathArrayItemValue) GetSingle(source *ServiceBusinessTier) (interface{}, bool) {
	return nil, false
}

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

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

// ServiceBusinessTier_FieldPathArrayOfValues allows storing slice of values for ServiceBusinessTier fields according to their type
type ServiceBusinessTier_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ServiceBusinessTier_FieldPath
}

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

func MustParseServiceBusinessTier_FieldPathArrayOfValues(pathStr, valuesStr string) ServiceBusinessTier_FieldPathArrayOfValues {
	fpaov, err := ParseServiceBusinessTier_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ServiceBusinessTier_FieldTerminalPathArrayOfValues struct {
	ServiceBusinessTier_FieldTerminalPath
	values interface{}
}

var _ ServiceBusinessTier_FieldPathArrayOfValues = (*ServiceBusinessTier_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ServiceBusinessTier_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ServiceBusinessTier_FieldPathSelectorService:
		for _, v := range fpaov.values.([]*meta_service.Name) {
			values = append(values, v)
		}
	case ServiceBusinessTier_FieldPathSelectorBusinessTier:
		for _, v := range fpaov.values.([]BusinessTier) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ServiceBusinessTier_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues() ([]*meta_service.Name, bool) {
	res, ok := fpaov.values.([]*meta_service.Name)
	return res, ok
}
func (fpaov *ServiceBusinessTier_FieldTerminalPathArrayOfValues) AsBusinessTierArrayOfValues() ([]BusinessTier, bool) {
	res, ok := fpaov.values.([]BusinessTier)
	return res, ok
}

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

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

type ServiceErrors_FieldPathSelector int32

const (
	ServiceErrors_FieldPathSelectorErrors ServiceErrors_FieldPathSelector = 0
)

func (s ServiceErrors_FieldPathSelector) String() string {
	switch s {
	case ServiceErrors_FieldPathSelectorErrors:
		return "errors"
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors: %d", s))
	}
}

func BuildServiceErrors_FieldPath(fp gotenobject.RawFieldPath) (ServiceErrors_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ServiceErrors")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "errors":
			return &ServiceErrors_FieldTerminalPath{selector: ServiceErrors_FieldPathSelectorErrors}, nil
		}
	} else {
		switch fp[0] {
		case "errors":
			if subpath, err := BuildServiceErrorsError_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ServiceErrors_FieldSubPath{selector: ServiceErrors_FieldPathSelectorErrors, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ServiceErrors", fp)
}

func ParseServiceErrors_FieldPath(rawField string) (ServiceErrors_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildServiceErrors_FieldPath(fp)
}

func MustParseServiceErrors_FieldPath(rawField string) ServiceErrors_FieldPath {
	fp, err := ParseServiceErrors_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ServiceErrors_FieldTerminalPath struct {
	selector ServiceErrors_FieldPathSelector
}

var _ ServiceErrors_FieldPath = (*ServiceErrors_FieldTerminalPath)(nil)

func (fp *ServiceErrors_FieldTerminalPath) Selector() ServiceErrors_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *ServiceErrors_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ServiceErrors_FieldPathSelectorErrors:
		return ([]*ServiceErrors_Error)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors: %d", fp.selector))
	}
}

func (fp *ServiceErrors_FieldTerminalPath) ClearValue(item *ServiceErrors) {
	if item != nil {
		switch fp.selector {
		case ServiceErrors_FieldPathSelectorErrors:
			item.Errors = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ServiceErrors: %d", fp.selector))
		}
	}
}

func (fp *ServiceErrors_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ServiceErrors))
}

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

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

func (fp *ServiceErrors_FieldTerminalPath) WithIValue(value interface{}) ServiceErrors_FieldPathValue {
	switch fp.selector {
	case ServiceErrors_FieldPathSelectorErrors:
		return &ServiceErrors_FieldTerminalPathValue{ServiceErrors_FieldTerminalPath: *fp, value: value.([]*ServiceErrors_Error)}
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors: %d", fp.selector))
	}
}

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

func (fp *ServiceErrors_FieldTerminalPath) WithIArrayOfValues(values interface{}) ServiceErrors_FieldPathArrayOfValues {
	fpaov := &ServiceErrors_FieldTerminalPathArrayOfValues{ServiceErrors_FieldTerminalPath: *fp}
	switch fp.selector {
	case ServiceErrors_FieldPathSelectorErrors:
		return &ServiceErrors_FieldTerminalPathArrayOfValues{ServiceErrors_FieldTerminalPath: *fp, values: values.([][]*ServiceErrors_Error)}
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *ServiceErrors_FieldTerminalPath) WithIArrayItemValue(value interface{}) ServiceErrors_FieldPathArrayItemValue {
	switch fp.selector {
	case ServiceErrors_FieldPathSelectorErrors:
		return &ServiceErrors_FieldTerminalPathArrayItemValue{ServiceErrors_FieldTerminalPath: *fp, value: value.(*ServiceErrors_Error)}
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors: %d", fp.selector))
	}
}

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

type ServiceErrors_FieldSubPath struct {
	selector ServiceErrors_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ServiceErrors_FieldPath = (*ServiceErrors_FieldSubPath)(nil)

func (fps *ServiceErrors_FieldSubPath) Selector() ServiceErrors_FieldPathSelector {
	return fps.selector
}
func (fps *ServiceErrors_FieldSubPath) AsErrorsSubPath() (ServiceErrorsError_FieldPath, bool) {
	res, ok := fps.subPath.(ServiceErrorsError_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *ServiceErrors_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ServiceErrors))
}

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

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

func (fps *ServiceErrors_FieldSubPath) WithIValue(value interface{}) ServiceErrors_FieldPathValue {
	return &ServiceErrors_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ServiceErrors_FieldSubPath) WithIArrayOfValues(values interface{}) ServiceErrors_FieldPathArrayOfValues {
	return &ServiceErrors_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ServiceErrors_FieldSubPath) WithIArrayItemValue(value interface{}) ServiceErrors_FieldPathArrayItemValue {
	return &ServiceErrors_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseServiceErrors_FieldPathValue(pathStr, valueStr string) ServiceErrors_FieldPathValue {
	fpv, err := ParseServiceErrors_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ServiceErrors_FieldTerminalPathValue struct {
	ServiceErrors_FieldTerminalPath
	value interface{}
}

var _ ServiceErrors_FieldPathValue = (*ServiceErrors_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ServiceErrors' as interface{}
func (fpv *ServiceErrors_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ServiceErrors_FieldTerminalPathValue) AsErrorsValue() ([]*ServiceErrors_Error, bool) {
	res, ok := fpv.value.([]*ServiceErrors_Error)
	return res, ok
}

// SetTo stores value for selected field for object ServiceErrors
func (fpv *ServiceErrors_FieldTerminalPathValue) SetTo(target **ServiceErrors) {
	if *target == nil {
		*target = new(ServiceErrors)
	}
	switch fpv.selector {
	case ServiceErrors_FieldPathSelectorErrors:
		(*target).Errors = fpv.value.([]*ServiceErrors_Error)
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors: %d", fpv.selector))
	}
}

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

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

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

type ServiceErrors_FieldSubPathValue struct {
	ServiceErrors_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ServiceErrors_FieldPathValue = (*ServiceErrors_FieldSubPathValue)(nil)

func (fpvs *ServiceErrors_FieldSubPathValue) AsErrorsPathValue() (ServiceErrorsError_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ServiceErrorsError_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseServiceErrors_FieldPathArrayItemValue(pathStr, valueStr string) ServiceErrors_FieldPathArrayItemValue {
	fpaiv, err := ParseServiceErrors_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ServiceErrors_FieldTerminalPathArrayItemValue struct {
	ServiceErrors_FieldTerminalPath
	value interface{}
}

var _ ServiceErrors_FieldPathArrayItemValue = (*ServiceErrors_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ServiceErrors as interface{}
func (fpaiv *ServiceErrors_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ServiceErrors_FieldTerminalPathArrayItemValue) AsErrorsItemValue() (*ServiceErrors_Error, bool) {
	res, ok := fpaiv.value.(*ServiceErrors_Error)
	return res, ok
}

func (fpaiv *ServiceErrors_FieldTerminalPathArrayItemValue) GetSingle(source *ServiceErrors) (interface{}, bool) {
	return nil, false
}

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

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

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

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

// ServiceErrors_FieldPathArrayOfValues allows storing slice of values for ServiceErrors fields according to their type
type ServiceErrors_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ServiceErrors_FieldPath
}

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

func MustParseServiceErrors_FieldPathArrayOfValues(pathStr, valuesStr string) ServiceErrors_FieldPathArrayOfValues {
	fpaov, err := ParseServiceErrors_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ServiceErrors_FieldTerminalPathArrayOfValues struct {
	ServiceErrors_FieldTerminalPath
	values interface{}
}

var _ ServiceErrors_FieldPathArrayOfValues = (*ServiceErrors_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ServiceErrors_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ServiceErrors_FieldPathSelectorErrors:
		for _, v := range fpaov.values.([][]*ServiceErrors_Error) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ServiceErrors_FieldTerminalPathArrayOfValues) AsErrorsArrayOfValues() ([][]*ServiceErrors_Error, bool) {
	res, ok := fpaov.values.([][]*ServiceErrors_Error)
	return res, ok
}

type ServiceErrors_FieldSubPathArrayOfValues struct {
	ServiceErrors_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ServiceErrors_FieldPathArrayOfValues = (*ServiceErrors_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ServiceErrors_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ServiceErrors_FieldSubPathArrayOfValues) AsErrorsPathArrayOfValues() (ServiceErrorsError_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ServiceErrorsError_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ServiceErrorsError_FieldPathSelector int32

const (
	ServiceErrorsError_FieldPathSelectorService ServiceErrorsError_FieldPathSelector = 0
	ServiceErrorsError_FieldPathSelectorMessage ServiceErrorsError_FieldPathSelector = 1
)

func (s ServiceErrorsError_FieldPathSelector) String() string {
	switch s {
	case ServiceErrorsError_FieldPathSelectorService:
		return "service"
	case ServiceErrorsError_FieldPathSelectorMessage:
		return "message"
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors_Error: %d", s))
	}
}

func BuildServiceErrorsError_FieldPath(fp gotenobject.RawFieldPath) (ServiceErrorsError_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ServiceErrors_Error")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service":
			return &ServiceErrorsError_FieldTerminalPath{selector: ServiceErrorsError_FieldPathSelectorService}, nil
		case "message":
			return &ServiceErrorsError_FieldTerminalPath{selector: ServiceErrorsError_FieldPathSelectorMessage}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ServiceErrors_Error", fp)
}

func ParseServiceErrorsError_FieldPath(rawField string) (ServiceErrorsError_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildServiceErrorsError_FieldPath(fp)
}

func MustParseServiceErrorsError_FieldPath(rawField string) ServiceErrorsError_FieldPath {
	fp, err := ParseServiceErrorsError_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ServiceErrorsError_FieldTerminalPath struct {
	selector ServiceErrorsError_FieldPathSelector
}

var _ ServiceErrorsError_FieldPath = (*ServiceErrorsError_FieldTerminalPath)(nil)

func (fp *ServiceErrorsError_FieldTerminalPath) Selector() ServiceErrorsError_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *ServiceErrorsError_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ServiceErrorsError_FieldPathSelectorService:
		return (*meta_service.Name)(nil)
	case ServiceErrorsError_FieldPathSelectorMessage:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors_Error: %d", fp.selector))
	}
}

func (fp *ServiceErrorsError_FieldTerminalPath) ClearValue(item *ServiceErrors_Error) {
	if item != nil {
		switch fp.selector {
		case ServiceErrorsError_FieldPathSelectorService:
			item.Service = nil
		case ServiceErrorsError_FieldPathSelectorMessage:
			item.Message = ""
		default:
			panic(fmt.Sprintf("Invalid selector for ServiceErrors_Error: %d", fp.selector))
		}
	}
}

func (fp *ServiceErrorsError_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ServiceErrors_Error))
}

// IsLeaf - whether field path is holds simple value
func (fp *ServiceErrorsError_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ServiceErrorsError_FieldPathSelectorService ||
		fp.selector == ServiceErrorsError_FieldPathSelectorMessage
}

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

func (fp *ServiceErrorsError_FieldTerminalPath) WithIValue(value interface{}) ServiceErrorsError_FieldPathValue {
	switch fp.selector {
	case ServiceErrorsError_FieldPathSelectorService:
		return &ServiceErrorsError_FieldTerminalPathValue{ServiceErrorsError_FieldTerminalPath: *fp, value: value.(*meta_service.Name)}
	case ServiceErrorsError_FieldPathSelectorMessage:
		return &ServiceErrorsError_FieldTerminalPathValue{ServiceErrorsError_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors_Error: %d", fp.selector))
	}
}

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

func (fp *ServiceErrorsError_FieldTerminalPath) WithIArrayOfValues(values interface{}) ServiceErrorsError_FieldPathArrayOfValues {
	fpaov := &ServiceErrorsError_FieldTerminalPathArrayOfValues{ServiceErrorsError_FieldTerminalPath: *fp}
	switch fp.selector {
	case ServiceErrorsError_FieldPathSelectorService:
		return &ServiceErrorsError_FieldTerminalPathArrayOfValues{ServiceErrorsError_FieldTerminalPath: *fp, values: values.([]*meta_service.Name)}
	case ServiceErrorsError_FieldPathSelectorMessage:
		return &ServiceErrorsError_FieldTerminalPathArrayOfValues{ServiceErrorsError_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors_Error: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// ServiceErrorsError_FieldPathValue allows storing values for Error fields according to their type
type ServiceErrorsError_FieldPathValue interface {
	ServiceErrorsError_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ServiceErrors_Error)
	CompareWith(*ServiceErrors_Error) (cmp int, comparable bool)
}

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

func MustParseServiceErrorsError_FieldPathValue(pathStr, valueStr string) ServiceErrorsError_FieldPathValue {
	fpv, err := ParseServiceErrorsError_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ServiceErrorsError_FieldTerminalPathValue struct {
	ServiceErrorsError_FieldTerminalPath
	value interface{}
}

var _ ServiceErrorsError_FieldPathValue = (*ServiceErrorsError_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Error' as interface{}
func (fpv *ServiceErrorsError_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ServiceErrorsError_FieldTerminalPathValue) AsServiceValue() (*meta_service.Name, bool) {
	res, ok := fpv.value.(*meta_service.Name)
	return res, ok
}
func (fpv *ServiceErrorsError_FieldTerminalPathValue) AsMessageValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Error
func (fpv *ServiceErrorsError_FieldTerminalPathValue) SetTo(target **ServiceErrors_Error) {
	if *target == nil {
		*target = new(ServiceErrors_Error)
	}
	switch fpv.selector {
	case ServiceErrorsError_FieldPathSelectorService:
		(*target).Service = fpv.value.(*meta_service.Name)
	case ServiceErrorsError_FieldPathSelectorMessage:
		(*target).Message = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors_Error: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ServiceErrorsError_FieldTerminalPathValue' with the value under path in 'ServiceErrors_Error'.
func (fpv *ServiceErrorsError_FieldTerminalPathValue) CompareWith(source *ServiceErrors_Error) (int, bool) {
	switch fpv.selector {
	case ServiceErrorsError_FieldPathSelectorService:
		leftValue := fpv.value.(*meta_service.Name)
		rightValue := source.GetService()
		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 ServiceErrorsError_FieldPathSelectorMessage:
		leftValue := fpv.value.(string)
		rightValue := source.GetMessage()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ServiceErrors_Error: %d", fpv.selector))
	}
}

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

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

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

func MustParseServiceErrorsError_FieldPathArrayItemValue(pathStr, valueStr string) ServiceErrorsError_FieldPathArrayItemValue {
	fpaiv, err := ParseServiceErrorsError_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ServiceErrorsError_FieldTerminalPathArrayItemValue struct {
	ServiceErrorsError_FieldTerminalPath
	value interface{}
}

var _ ServiceErrorsError_FieldPathArrayItemValue = (*ServiceErrorsError_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ServiceErrorsError_FieldTerminalPathArrayItemValue) GetSingle(source *ServiceErrors_Error) (interface{}, bool) {
	return nil, false
}

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

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

// ServiceErrorsError_FieldPathArrayOfValues allows storing slice of values for Error fields according to their type
type ServiceErrorsError_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ServiceErrorsError_FieldPath
}

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

func MustParseServiceErrorsError_FieldPathArrayOfValues(pathStr, valuesStr string) ServiceErrorsError_FieldPathArrayOfValues {
	fpaov, err := ParseServiceErrorsError_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ServiceErrorsError_FieldTerminalPathArrayOfValues struct {
	ServiceErrorsError_FieldTerminalPath
	values interface{}
}

var _ ServiceErrorsError_FieldPathArrayOfValues = (*ServiceErrorsError_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ServiceErrorsError_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ServiceErrorsError_FieldPathSelectorService:
		for _, v := range fpaov.values.([]*meta_service.Name) {
			values = append(values, v)
		}
	case ServiceErrorsError_FieldPathSelectorMessage:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ServiceErrorsError_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues() ([]*meta_service.Name, bool) {
	res, ok := fpaov.values.([]*meta_service.Name)
	return res, ok
}
func (fpaov *ServiceErrorsError_FieldTerminalPathArrayOfValues) AsMessageArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}