metric_descriptor.pb.fieldpath.go

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

package metric_descriptor

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 (
	api "github.com/cloudwan/edgelq-sdk/common/api"
	common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	monitored_resource_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/monitored_resource_descriptor"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/project"
	meta "github.com/cloudwan/goten-sdk/types/meta"
)

// 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 (
	_ = api.LaunchStage(0)
	_ = &common.LabelDescriptor{}
	_ = &monitored_resource_descriptor.MonitoredResourceDescriptor{}
	_ = &project.Project{}
	_ = &meta.Meta{}
)

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

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

type MetricDescriptor_FieldPathSelector int32

const (
	MetricDescriptor_FieldPathSelectorName                      MetricDescriptor_FieldPathSelector = 0
	MetricDescriptor_FieldPathSelectorMetadata                  MetricDescriptor_FieldPathSelector = 1
	MetricDescriptor_FieldPathSelectorType                      MetricDescriptor_FieldPathSelector = 2
	MetricDescriptor_FieldPathSelectorResourceTypes             MetricDescriptor_FieldPathSelector = 3
	MetricDescriptor_FieldPathSelectorLabels                    MetricDescriptor_FieldPathSelector = 4
	MetricDescriptor_FieldPathSelectorMetricKind                MetricDescriptor_FieldPathSelector = 5
	MetricDescriptor_FieldPathSelectorValueType                 MetricDescriptor_FieldPathSelector = 6
	MetricDescriptor_FieldPathSelectorUnit                      MetricDescriptor_FieldPathSelector = 7
	MetricDescriptor_FieldPathSelectorDescription               MetricDescriptor_FieldPathSelector = 8
	MetricDescriptor_FieldPathSelectorDisplayName               MetricDescriptor_FieldPathSelector = 9
	MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata  MetricDescriptor_FieldPathSelector = 10
	MetricDescriptor_FieldPathSelectorDistributionBucketOptions MetricDescriptor_FieldPathSelector = 11
	MetricDescriptor_FieldPathSelectorPromotedLabelKeySets      MetricDescriptor_FieldPathSelector = 12
	MetricDescriptor_FieldPathSelectorIndexSpec                 MetricDescriptor_FieldPathSelector = 13
	MetricDescriptor_FieldPathSelectorStorageConfig             MetricDescriptor_FieldPathSelector = 14
)

func (s MetricDescriptor_FieldPathSelector) String() string {
	switch s {
	case MetricDescriptor_FieldPathSelectorName:
		return "name"
	case MetricDescriptor_FieldPathSelectorMetadata:
		return "metadata"
	case MetricDescriptor_FieldPathSelectorType:
		return "type"
	case MetricDescriptor_FieldPathSelectorResourceTypes:
		return "resource_types"
	case MetricDescriptor_FieldPathSelectorLabels:
		return "labels"
	case MetricDescriptor_FieldPathSelectorMetricKind:
		return "metric_kind"
	case MetricDescriptor_FieldPathSelectorValueType:
		return "value_type"
	case MetricDescriptor_FieldPathSelectorUnit:
		return "unit"
	case MetricDescriptor_FieldPathSelectorDescription:
		return "description"
	case MetricDescriptor_FieldPathSelectorDisplayName:
		return "display_name"
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		return "metric_descriptor_metadata"
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		return "distribution_bucket_options"
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		return "promoted_label_key_sets"
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		return "index_spec"
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		return "storage_config"
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", s))
	}
}

func BuildMetricDescriptor_FieldPath(fp gotenobject.RawFieldPath) (MetricDescriptor_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object MetricDescriptor")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorName}, nil
		case "metadata":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorMetadata}, nil
		case "type":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorType}, nil
		case "resource_types", "resourceTypes", "resource-types":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorResourceTypes}, nil
		case "labels":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorLabels}, nil
		case "metric_kind", "metricKind", "metric-kind":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorMetricKind}, nil
		case "value_type", "valueType", "value-type":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorValueType}, nil
		case "unit":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorUnit}, nil
		case "description":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorDescription}, nil
		case "display_name", "displayName", "display-name":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorDisplayName}, nil
		case "metric_descriptor_metadata", "metricDescriptorMetadata", "metric-descriptor-metadata":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata}, nil
		case "distribution_bucket_options", "distributionBucketOptions", "distribution-bucket-options":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorDistributionBucketOptions}, nil
		case "promoted_label_key_sets", "promotedLabelKeySets", "promoted-label-key-sets":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorPromotedLabelKeySets}, nil
		case "index_spec", "indexSpec", "index-spec":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorIndexSpec}, nil
		case "storage_config", "storageConfig", "storage-config":
			return &MetricDescriptor_FieldTerminalPath{selector: MetricDescriptor_FieldPathSelectorStorageConfig}, nil
		}
	} else {
		switch fp[0] {
		case "metadata":
			if subpath, err := meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &MetricDescriptor_FieldSubPath{selector: MetricDescriptor_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		case "labels":
			if subpath, err := common.BuildLabelDescriptor_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &MetricDescriptor_FieldSubPath{selector: MetricDescriptor_FieldPathSelectorLabels, subPath: subpath}, nil
			}
		case "metric_descriptor_metadata", "metricDescriptorMetadata", "metric-descriptor-metadata":
			if subpath, err := BuildMetricDescriptorMetricDescriptorMetadata_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &MetricDescriptor_FieldSubPath{selector: MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata, subPath: subpath}, nil
			}
		case "distribution_bucket_options", "distributionBucketOptions", "distribution-bucket-options":
			if subpath, err := common.BuildDistributionBucketOptions_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &MetricDescriptor_FieldSubPath{selector: MetricDescriptor_FieldPathSelectorDistributionBucketOptions, subPath: subpath}, nil
			}
		case "promoted_label_key_sets", "promotedLabelKeySets", "promoted-label-key-sets":
			if subpath, err := common.BuildLabelKeySet_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &MetricDescriptor_FieldSubPath{selector: MetricDescriptor_FieldPathSelectorPromotedLabelKeySets, subPath: subpath}, nil
			}
		case "index_spec", "indexSpec", "index-spec":
			if subpath, err := BuildMetricDescriptorIndexSpec_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &MetricDescriptor_FieldSubPath{selector: MetricDescriptor_FieldPathSelectorIndexSpec, subPath: subpath}, nil
			}
		case "storage_config", "storageConfig", "storage-config":
			if subpath, err := BuildMetricDescriptorStorageConfig_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &MetricDescriptor_FieldSubPath{selector: MetricDescriptor_FieldPathSelectorStorageConfig, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object MetricDescriptor", fp)
}

func ParseMetricDescriptor_FieldPath(rawField string) (MetricDescriptor_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildMetricDescriptor_FieldPath(fp)
}

func MustParseMetricDescriptor_FieldPath(rawField string) MetricDescriptor_FieldPath {
	fp, err := ParseMetricDescriptor_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type MetricDescriptor_FieldTerminalPath struct {
	selector MetricDescriptor_FieldPathSelector
}

var _ MetricDescriptor_FieldPath = (*MetricDescriptor_FieldTerminalPath)(nil)

func (fp *MetricDescriptor_FieldTerminalPath) Selector() MetricDescriptor_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source MetricDescriptor
func (fp *MetricDescriptor_FieldTerminalPath) Get(source *MetricDescriptor) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case MetricDescriptor_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case MetricDescriptor_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		case MetricDescriptor_FieldPathSelectorType:
			values = append(values, source.Type)
		case MetricDescriptor_FieldPathSelectorResourceTypes:
			for _, value := range source.GetResourceTypes() {
				values = append(values, value)
			}
		case MetricDescriptor_FieldPathSelectorLabels:
			for _, value := range source.GetLabels() {
				values = append(values, value)
			}
		case MetricDescriptor_FieldPathSelectorMetricKind:
			values = append(values, source.MetricKind)
		case MetricDescriptor_FieldPathSelectorValueType:
			values = append(values, source.ValueType)
		case MetricDescriptor_FieldPathSelectorUnit:
			values = append(values, source.Unit)
		case MetricDescriptor_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case MetricDescriptor_FieldPathSelectorDisplayName:
			values = append(values, source.DisplayName)
		case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
			if source.MetricDescriptorMetadata != nil {
				values = append(values, source.MetricDescriptorMetadata)
			}
		case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
			if source.DistributionBucketOptions != nil {
				values = append(values, source.DistributionBucketOptions)
			}
		case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
			for _, value := range source.GetPromotedLabelKeySets() {
				values = append(values, value)
			}
		case MetricDescriptor_FieldPathSelectorIndexSpec:
			if source.IndexSpec != nil {
				values = append(values, source.IndexSpec)
			}
		case MetricDescriptor_FieldPathSelectorStorageConfig:
			if source.StorageConfig != nil {
				values = append(values, source.StorageConfig)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source MetricDescriptor
func (fp *MetricDescriptor_FieldTerminalPath) GetSingle(source *MetricDescriptor) (interface{}, bool) {
	switch fp.selector {
	case MetricDescriptor_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case MetricDescriptor_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		return res, res != nil
	case MetricDescriptor_FieldPathSelectorType:
		return source.GetType(), source != nil
	case MetricDescriptor_FieldPathSelectorResourceTypes:
		res := source.GetResourceTypes()
		return res, res != nil
	case MetricDescriptor_FieldPathSelectorLabels:
		res := source.GetLabels()
		return res, res != nil
	case MetricDescriptor_FieldPathSelectorMetricKind:
		return source.GetMetricKind(), source != nil
	case MetricDescriptor_FieldPathSelectorValueType:
		return source.GetValueType(), source != nil
	case MetricDescriptor_FieldPathSelectorUnit:
		return source.GetUnit(), source != nil
	case MetricDescriptor_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case MetricDescriptor_FieldPathSelectorDisplayName:
		return source.GetDisplayName(), source != nil
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		res := source.GetMetricDescriptorMetadata()
		return res, res != nil
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		res := source.GetDistributionBucketOptions()
		return res, res != nil
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		res := source.GetPromotedLabelKeySets()
		return res, res != nil
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		res := source.GetIndexSpec()
		return res, res != nil
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		res := source.GetStorageConfig()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *MetricDescriptor_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case MetricDescriptor_FieldPathSelectorName:
		return (*Name)(nil)
	case MetricDescriptor_FieldPathSelectorMetadata:
		return (*meta.Meta)(nil)
	case MetricDescriptor_FieldPathSelectorType:
		return ""
	case MetricDescriptor_FieldPathSelectorResourceTypes:
		return ([]string)(nil)
	case MetricDescriptor_FieldPathSelectorLabels:
		return ([]*common.LabelDescriptor)(nil)
	case MetricDescriptor_FieldPathSelectorMetricKind:
		return MetricDescriptor_METRIC_KIND_UNSPECIFIED
	case MetricDescriptor_FieldPathSelectorValueType:
		return MetricDescriptor_VALUE_TYPE_UNSPECIFIED
	case MetricDescriptor_FieldPathSelectorUnit:
		return ""
	case MetricDescriptor_FieldPathSelectorDescription:
		return ""
	case MetricDescriptor_FieldPathSelectorDisplayName:
		return ""
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		return (*MetricDescriptor_MetricDescriptorMetadata)(nil)
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		return (*common.Distribution_BucketOptions)(nil)
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		return ([]*common.LabelKeySet)(nil)
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		return (*MetricDescriptor_IndexSpec)(nil)
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		return (*MetricDescriptor_StorageConfig)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fp.selector))
	}
}

func (fp *MetricDescriptor_FieldTerminalPath) ClearValue(item *MetricDescriptor) {
	if item != nil {
		switch fp.selector {
		case MetricDescriptor_FieldPathSelectorName:
			item.Name = nil
		case MetricDescriptor_FieldPathSelectorMetadata:
			item.Metadata = nil
		case MetricDescriptor_FieldPathSelectorType:
			item.Type = ""
		case MetricDescriptor_FieldPathSelectorResourceTypes:
			item.ResourceTypes = nil
		case MetricDescriptor_FieldPathSelectorLabels:
			item.Labels = nil
		case MetricDescriptor_FieldPathSelectorMetricKind:
			item.MetricKind = MetricDescriptor_METRIC_KIND_UNSPECIFIED
		case MetricDescriptor_FieldPathSelectorValueType:
			item.ValueType = MetricDescriptor_VALUE_TYPE_UNSPECIFIED
		case MetricDescriptor_FieldPathSelectorUnit:
			item.Unit = ""
		case MetricDescriptor_FieldPathSelectorDescription:
			item.Description = ""
		case MetricDescriptor_FieldPathSelectorDisplayName:
			item.DisplayName = ""
		case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
			item.MetricDescriptorMetadata = nil
		case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
			item.DistributionBucketOptions = nil
		case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
			item.PromotedLabelKeySets = nil
		case MetricDescriptor_FieldPathSelectorIndexSpec:
			item.IndexSpec = nil
		case MetricDescriptor_FieldPathSelectorStorageConfig:
			item.StorageConfig = nil
		default:
			panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fp.selector))
		}
	}
}

func (fp *MetricDescriptor_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*MetricDescriptor))
}

// IsLeaf - whether field path is holds simple value
func (fp *MetricDescriptor_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == MetricDescriptor_FieldPathSelectorName ||
		fp.selector == MetricDescriptor_FieldPathSelectorType ||
		fp.selector == MetricDescriptor_FieldPathSelectorResourceTypes ||
		fp.selector == MetricDescriptor_FieldPathSelectorMetricKind ||
		fp.selector == MetricDescriptor_FieldPathSelectorValueType ||
		fp.selector == MetricDescriptor_FieldPathSelectorUnit ||
		fp.selector == MetricDescriptor_FieldPathSelectorDescription ||
		fp.selector == MetricDescriptor_FieldPathSelectorDisplayName
}

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

func (fp *MetricDescriptor_FieldTerminalPath) WithIValue(value interface{}) MetricDescriptor_FieldPathValue {
	switch fp.selector {
	case MetricDescriptor_FieldPathSelectorName:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(*Name)}
	case MetricDescriptor_FieldPathSelectorMetadata:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(*meta.Meta)}
	case MetricDescriptor_FieldPathSelectorType:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(string)}
	case MetricDescriptor_FieldPathSelectorResourceTypes:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.([]string)}
	case MetricDescriptor_FieldPathSelectorLabels:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.([]*common.LabelDescriptor)}
	case MetricDescriptor_FieldPathSelectorMetricKind:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(MetricDescriptor_MetricKind)}
	case MetricDescriptor_FieldPathSelectorValueType:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(MetricDescriptor_ValueType)}
	case MetricDescriptor_FieldPathSelectorUnit:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(string)}
	case MetricDescriptor_FieldPathSelectorDescription:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(string)}
	case MetricDescriptor_FieldPathSelectorDisplayName:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(string)}
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(*MetricDescriptor_MetricDescriptorMetadata)}
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(*common.Distribution_BucketOptions)}
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.([]*common.LabelKeySet)}
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(*MetricDescriptor_IndexSpec)}
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		return &MetricDescriptor_FieldTerminalPathValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(*MetricDescriptor_StorageConfig)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fp.selector))
	}
}

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

func (fp *MetricDescriptor_FieldTerminalPath) WithIArrayOfValues(values interface{}) MetricDescriptor_FieldPathArrayOfValues {
	fpaov := &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp}
	switch fp.selector {
	case MetricDescriptor_FieldPathSelectorName:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]*Name)}
	case MetricDescriptor_FieldPathSelectorMetadata:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]*meta.Meta)}
	case MetricDescriptor_FieldPathSelectorType:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]string)}
	case MetricDescriptor_FieldPathSelectorResourceTypes:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([][]string)}
	case MetricDescriptor_FieldPathSelectorLabels:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([][]*common.LabelDescriptor)}
	case MetricDescriptor_FieldPathSelectorMetricKind:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]MetricDescriptor_MetricKind)}
	case MetricDescriptor_FieldPathSelectorValueType:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]MetricDescriptor_ValueType)}
	case MetricDescriptor_FieldPathSelectorUnit:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]string)}
	case MetricDescriptor_FieldPathSelectorDescription:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]string)}
	case MetricDescriptor_FieldPathSelectorDisplayName:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]string)}
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]*MetricDescriptor_MetricDescriptorMetadata)}
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]*common.Distribution_BucketOptions)}
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([][]*common.LabelKeySet)}
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]*MetricDescriptor_IndexSpec)}
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		return &MetricDescriptor_FieldTerminalPathArrayOfValues{MetricDescriptor_FieldTerminalPath: *fp, values: values.([]*MetricDescriptor_StorageConfig)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *MetricDescriptor_FieldTerminalPath) WithIArrayItemValue(value interface{}) MetricDescriptor_FieldPathArrayItemValue {
	switch fp.selector {
	case MetricDescriptor_FieldPathSelectorResourceTypes:
		return &MetricDescriptor_FieldTerminalPathArrayItemValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(string)}
	case MetricDescriptor_FieldPathSelectorLabels:
		return &MetricDescriptor_FieldTerminalPathArrayItemValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(*common.LabelDescriptor)}
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		return &MetricDescriptor_FieldTerminalPathArrayItemValue{MetricDescriptor_FieldTerminalPath: *fp, value: value.(*common.LabelKeySet)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fp.selector))
	}
}

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

type MetricDescriptor_FieldSubPath struct {
	selector MetricDescriptor_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ MetricDescriptor_FieldPath = (*MetricDescriptor_FieldSubPath)(nil)

func (fps *MetricDescriptor_FieldSubPath) Selector() MetricDescriptor_FieldPathSelector {
	return fps.selector
}
func (fps *MetricDescriptor_FieldSubPath) AsMetadataSubPath() (meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(meta.Meta_FieldPath)
	return res, ok
}
func (fps *MetricDescriptor_FieldSubPath) AsLabelsSubPath() (common.LabelDescriptor_FieldPath, bool) {
	res, ok := fps.subPath.(common.LabelDescriptor_FieldPath)
	return res, ok
}
func (fps *MetricDescriptor_FieldSubPath) AsMetricDescriptorMetadataSubPath() (MetricDescriptorMetricDescriptorMetadata_FieldPath, bool) {
	res, ok := fps.subPath.(MetricDescriptorMetricDescriptorMetadata_FieldPath)
	return res, ok
}
func (fps *MetricDescriptor_FieldSubPath) AsDistributionBucketOptionsSubPath() (common.DistributionBucketOptions_FieldPath, bool) {
	res, ok := fps.subPath.(common.DistributionBucketOptions_FieldPath)
	return res, ok
}
func (fps *MetricDescriptor_FieldSubPath) AsPromotedLabelKeySetsSubPath() (common.LabelKeySet_FieldPath, bool) {
	res, ok := fps.subPath.(common.LabelKeySet_FieldPath)
	return res, ok
}
func (fps *MetricDescriptor_FieldSubPath) AsIndexSpecSubPath() (MetricDescriptorIndexSpec_FieldPath, bool) {
	res, ok := fps.subPath.(MetricDescriptorIndexSpec_FieldPath)
	return res, ok
}
func (fps *MetricDescriptor_FieldSubPath) AsStorageConfigSubPath() (MetricDescriptorStorageConfig_FieldPath, bool) {
	res, ok := fps.subPath.(MetricDescriptorStorageConfig_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source MetricDescriptor
func (fps *MetricDescriptor_FieldSubPath) Get(source *MetricDescriptor) (values []interface{}) {
	switch fps.selector {
	case MetricDescriptor_FieldPathSelectorMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetMetadata())...)
	case MetricDescriptor_FieldPathSelectorLabels:
		for _, item := range source.GetLabels() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetMetricDescriptorMetadata())...)
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		values = append(values, fps.subPath.GetRaw(source.GetDistributionBucketOptions())...)
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		for _, item := range source.GetPromotedLabelKeySets() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		values = append(values, fps.subPath.GetRaw(source.GetIndexSpec())...)
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		values = append(values, fps.subPath.GetRaw(source.GetStorageConfig())...)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source MetricDescriptor
func (fps *MetricDescriptor_FieldSubPath) GetSingle(source *MetricDescriptor) (interface{}, bool) {
	switch fps.selector {
	case MetricDescriptor_FieldPathSelectorMetadata:
		if source.GetMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetadata())
	case MetricDescriptor_FieldPathSelectorLabels:
		if len(source.GetLabels()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetLabels()[0])
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		if source.GetMetricDescriptorMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetricDescriptorMetadata())
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		if source.GetDistributionBucketOptions() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetDistributionBucketOptions())
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		if len(source.GetPromotedLabelKeySets()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetPromotedLabelKeySets()[0])
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		if source.GetIndexSpec() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetIndexSpec())
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		if source.GetStorageConfig() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetStorageConfig())
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fps.selector))
	}
}

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

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

func (fps *MetricDescriptor_FieldSubPath) ClearValue(item *MetricDescriptor) {
	if item != nil {
		switch fps.selector {
		case MetricDescriptor_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		case MetricDescriptor_FieldPathSelectorLabels:
			for _, subItem := range item.Labels {
				fps.subPath.ClearValueRaw(subItem)
			}
		case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
			fps.subPath.ClearValueRaw(item.MetricDescriptorMetadata)
		case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
			fps.subPath.ClearValueRaw(item.DistributionBucketOptions)
		case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
			for _, subItem := range item.PromotedLabelKeySets {
				fps.subPath.ClearValueRaw(subItem)
			}
		case MetricDescriptor_FieldPathSelectorIndexSpec:
			fps.subPath.ClearValueRaw(item.IndexSpec)
		case MetricDescriptor_FieldPathSelectorStorageConfig:
			fps.subPath.ClearValueRaw(item.StorageConfig)
		default:
			panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fps.selector))
		}
	}
}

func (fps *MetricDescriptor_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*MetricDescriptor))
}

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

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

func (fps *MetricDescriptor_FieldSubPath) WithIValue(value interface{}) MetricDescriptor_FieldPathValue {
	return &MetricDescriptor_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *MetricDescriptor_FieldSubPath) WithIArrayOfValues(values interface{}) MetricDescriptor_FieldPathArrayOfValues {
	return &MetricDescriptor_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *MetricDescriptor_FieldSubPath) WithIArrayItemValue(value interface{}) MetricDescriptor_FieldPathArrayItemValue {
	return &MetricDescriptor_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseMetricDescriptor_FieldPathValue(pathStr, valueStr string) MetricDescriptor_FieldPathValue {
	fpv, err := ParseMetricDescriptor_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type MetricDescriptor_FieldTerminalPathValue struct {
	MetricDescriptor_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptor_FieldPathValue = (*MetricDescriptor_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'MetricDescriptor' as interface{}
func (fpv *MetricDescriptor_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsMetadataValue() (*meta.Meta, bool) {
	res, ok := fpv.value.(*meta.Meta)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsResourceTypesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsLabelsValue() ([]*common.LabelDescriptor, bool) {
	res, ok := fpv.value.([]*common.LabelDescriptor)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsMetricKindValue() (MetricDescriptor_MetricKind, bool) {
	res, ok := fpv.value.(MetricDescriptor_MetricKind)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsValueTypeValue() (MetricDescriptor_ValueType, bool) {
	res, ok := fpv.value.(MetricDescriptor_ValueType)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsUnitValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsMetricDescriptorMetadataValue() (*MetricDescriptor_MetricDescriptorMetadata, bool) {
	res, ok := fpv.value.(*MetricDescriptor_MetricDescriptorMetadata)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsDistributionBucketOptionsValue() (*common.Distribution_BucketOptions, bool) {
	res, ok := fpv.value.(*common.Distribution_BucketOptions)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsPromotedLabelKeySetsValue() ([]*common.LabelKeySet, bool) {
	res, ok := fpv.value.([]*common.LabelKeySet)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsIndexSpecValue() (*MetricDescriptor_IndexSpec, bool) {
	res, ok := fpv.value.(*MetricDescriptor_IndexSpec)
	return res, ok
}
func (fpv *MetricDescriptor_FieldTerminalPathValue) AsStorageConfigValue() (*MetricDescriptor_StorageConfig, bool) {
	res, ok := fpv.value.(*MetricDescriptor_StorageConfig)
	return res, ok
}

// SetTo stores value for selected field for object MetricDescriptor
func (fpv *MetricDescriptor_FieldTerminalPathValue) SetTo(target **MetricDescriptor) {
	if *target == nil {
		*target = new(MetricDescriptor)
	}
	switch fpv.selector {
	case MetricDescriptor_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case MetricDescriptor_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*meta.Meta)
	case MetricDescriptor_FieldPathSelectorType:
		(*target).Type = fpv.value.(string)
	case MetricDescriptor_FieldPathSelectorResourceTypes:
		(*target).ResourceTypes = fpv.value.([]string)
	case MetricDescriptor_FieldPathSelectorLabels:
		(*target).Labels = fpv.value.([]*common.LabelDescriptor)
	case MetricDescriptor_FieldPathSelectorMetricKind:
		(*target).MetricKind = fpv.value.(MetricDescriptor_MetricKind)
	case MetricDescriptor_FieldPathSelectorValueType:
		(*target).ValueType = fpv.value.(MetricDescriptor_ValueType)
	case MetricDescriptor_FieldPathSelectorUnit:
		(*target).Unit = fpv.value.(string)
	case MetricDescriptor_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case MetricDescriptor_FieldPathSelectorDisplayName:
		(*target).DisplayName = fpv.value.(string)
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		(*target).MetricDescriptorMetadata = fpv.value.(*MetricDescriptor_MetricDescriptorMetadata)
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		(*target).DistributionBucketOptions = fpv.value.(*common.Distribution_BucketOptions)
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		(*target).PromotedLabelKeySets = fpv.value.([]*common.LabelKeySet)
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		(*target).IndexSpec = fpv.value.(*MetricDescriptor_IndexSpec)
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		(*target).StorageConfig = fpv.value.(*MetricDescriptor_StorageConfig)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'MetricDescriptor_FieldTerminalPathValue' with the value under path in 'MetricDescriptor'.
func (fpv *MetricDescriptor_FieldTerminalPathValue) CompareWith(source *MetricDescriptor) (int, bool) {
	switch fpv.selector {
	case MetricDescriptor_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 MetricDescriptor_FieldPathSelectorMetadata:
		return 0, false
	case MetricDescriptor_FieldPathSelectorType:
		leftValue := fpv.value.(string)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case MetricDescriptor_FieldPathSelectorResourceTypes:
		return 0, false
	case MetricDescriptor_FieldPathSelectorLabels:
		return 0, false
	case MetricDescriptor_FieldPathSelectorMetricKind:
		leftValue := fpv.value.(MetricDescriptor_MetricKind)
		rightValue := source.GetMetricKind()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case MetricDescriptor_FieldPathSelectorValueType:
		leftValue := fpv.value.(MetricDescriptor_ValueType)
		rightValue := source.GetValueType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case MetricDescriptor_FieldPathSelectorUnit:
		leftValue := fpv.value.(string)
		rightValue := source.GetUnit()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case MetricDescriptor_FieldPathSelectorDescription:
		leftValue := fpv.value.(string)
		rightValue := source.GetDescription()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case MetricDescriptor_FieldPathSelectorDisplayName:
		leftValue := fpv.value.(string)
		rightValue := source.GetDisplayName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		return 0, false
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		return 0, false
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		return 0, false
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		return 0, false
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fpv.selector))
	}
}

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

type MetricDescriptor_FieldSubPathValue struct {
	MetricDescriptor_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ MetricDescriptor_FieldPathValue = (*MetricDescriptor_FieldSubPathValue)(nil)

func (fpvs *MetricDescriptor_FieldSubPathValue) AsMetadataPathValue() (meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(meta.Meta_FieldPathValue)
	return res, ok
}
func (fpvs *MetricDescriptor_FieldSubPathValue) AsLabelsPathValue() (common.LabelDescriptor_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.LabelDescriptor_FieldPathValue)
	return res, ok
}
func (fpvs *MetricDescriptor_FieldSubPathValue) AsMetricDescriptorMetadataPathValue() (MetricDescriptorMetricDescriptorMetadata_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(MetricDescriptorMetricDescriptorMetadata_FieldPathValue)
	return res, ok
}
func (fpvs *MetricDescriptor_FieldSubPathValue) AsDistributionBucketOptionsPathValue() (common.DistributionBucketOptions_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.DistributionBucketOptions_FieldPathValue)
	return res, ok
}
func (fpvs *MetricDescriptor_FieldSubPathValue) AsPromotedLabelKeySetsPathValue() (common.LabelKeySet_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.LabelKeySet_FieldPathValue)
	return res, ok
}
func (fpvs *MetricDescriptor_FieldSubPathValue) AsIndexSpecPathValue() (MetricDescriptorIndexSpec_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(MetricDescriptorIndexSpec_FieldPathValue)
	return res, ok
}
func (fpvs *MetricDescriptor_FieldSubPathValue) AsStorageConfigPathValue() (MetricDescriptorStorageConfig_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(MetricDescriptorStorageConfig_FieldPathValue)
	return res, ok
}

func (fpvs *MetricDescriptor_FieldSubPathValue) SetTo(target **MetricDescriptor) {
	if *target == nil {
		*target = new(MetricDescriptor)
	}
	switch fpvs.Selector() {
	case MetricDescriptor_FieldPathSelectorMetadata:
		fpvs.subPathValue.(meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	case MetricDescriptor_FieldPathSelectorLabels:
		panic("FieldPath setter is unsupported for array subpaths")
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		fpvs.subPathValue.(MetricDescriptorMetricDescriptorMetadata_FieldPathValue).SetTo(&(*target).MetricDescriptorMetadata)
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		fpvs.subPathValue.(common.DistributionBucketOptions_FieldPathValue).SetTo(&(*target).DistributionBucketOptions)
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		panic("FieldPath setter is unsupported for array subpaths")
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		fpvs.subPathValue.(MetricDescriptorIndexSpec_FieldPathValue).SetTo(&(*target).IndexSpec)
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		fpvs.subPathValue.(MetricDescriptorStorageConfig_FieldPathValue).SetTo(&(*target).StorageConfig)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *MetricDescriptor_FieldSubPathValue) CompareWith(source *MetricDescriptor) (int, bool) {
	switch fpvs.Selector() {
	case MetricDescriptor_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	case MetricDescriptor_FieldPathSelectorLabels:
		return 0, false // repeated field
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		return fpvs.subPathValue.(MetricDescriptorMetricDescriptorMetadata_FieldPathValue).CompareWith(source.GetMetricDescriptorMetadata())
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		return fpvs.subPathValue.(common.DistributionBucketOptions_FieldPathValue).CompareWith(source.GetDistributionBucketOptions())
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		return 0, false // repeated field
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		return fpvs.subPathValue.(MetricDescriptorIndexSpec_FieldPathValue).CompareWith(source.GetIndexSpec())
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		return fpvs.subPathValue.(MetricDescriptorStorageConfig_FieldPathValue).CompareWith(source.GetStorageConfig())
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseMetricDescriptor_FieldPathArrayItemValue(pathStr, valueStr string) MetricDescriptor_FieldPathArrayItemValue {
	fpaiv, err := ParseMetricDescriptor_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type MetricDescriptor_FieldTerminalPathArrayItemValue struct {
	MetricDescriptor_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptor_FieldPathArrayItemValue = (*MetricDescriptor_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object MetricDescriptor as interface{}
func (fpaiv *MetricDescriptor_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *MetricDescriptor_FieldTerminalPathArrayItemValue) AsResourceTypesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *MetricDescriptor_FieldTerminalPathArrayItemValue) AsLabelsItemValue() (*common.LabelDescriptor, bool) {
	res, ok := fpaiv.value.(*common.LabelDescriptor)
	return res, ok
}
func (fpaiv *MetricDescriptor_FieldTerminalPathArrayItemValue) AsPromotedLabelKeySetsItemValue() (*common.LabelKeySet, bool) {
	res, ok := fpaiv.value.(*common.LabelKeySet)
	return res, ok
}

func (fpaiv *MetricDescriptor_FieldTerminalPathArrayItemValue) GetSingle(source *MetricDescriptor) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *MetricDescriptor_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *MetricDescriptor_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *MetricDescriptor_FieldSubPathArrayItemValue) AsLabelsPathItemValue() (common.LabelDescriptor_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.LabelDescriptor_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *MetricDescriptor_FieldSubPathArrayItemValue) AsMetricDescriptorMetadataPathItemValue() (MetricDescriptorMetricDescriptorMetadata_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(MetricDescriptorMetricDescriptorMetadata_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *MetricDescriptor_FieldSubPathArrayItemValue) AsDistributionBucketOptionsPathItemValue() (common.DistributionBucketOptions_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.DistributionBucketOptions_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *MetricDescriptor_FieldSubPathArrayItemValue) AsPromotedLabelKeySetsPathItemValue() (common.LabelKeySet_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.LabelKeySet_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *MetricDescriptor_FieldSubPathArrayItemValue) AsIndexSpecPathItemValue() (MetricDescriptorIndexSpec_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(MetricDescriptorIndexSpec_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *MetricDescriptor_FieldSubPathArrayItemValue) AsStorageConfigPathItemValue() (MetricDescriptorStorageConfig_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(MetricDescriptorStorageConfig_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'MetricDescriptor'
func (fpaivs *MetricDescriptor_FieldSubPathArrayItemValue) ContainsValue(source *MetricDescriptor) bool {
	switch fpaivs.Selector() {
	case MetricDescriptor_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	case MetricDescriptor_FieldPathSelectorLabels:
		return false // repeated/map field
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		return fpaivs.subPathItemValue.(MetricDescriptorMetricDescriptorMetadata_FieldPathArrayItemValue).ContainsValue(source.GetMetricDescriptorMetadata())
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		return fpaivs.subPathItemValue.(common.DistributionBucketOptions_FieldPathArrayItemValue).ContainsValue(source.GetDistributionBucketOptions())
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		return false // repeated/map field
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		return fpaivs.subPathItemValue.(MetricDescriptorIndexSpec_FieldPathArrayItemValue).ContainsValue(source.GetIndexSpec())
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		return fpaivs.subPathItemValue.(MetricDescriptorStorageConfig_FieldPathArrayItemValue).ContainsValue(source.GetStorageConfig())
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor: %d", fpaivs.Selector()))
	}
}

// MetricDescriptor_FieldPathArrayOfValues allows storing slice of values for MetricDescriptor fields according to their type
type MetricDescriptor_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	MetricDescriptor_FieldPath
}

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

func MustParseMetricDescriptor_FieldPathArrayOfValues(pathStr, valuesStr string) MetricDescriptor_FieldPathArrayOfValues {
	fpaov, err := ParseMetricDescriptor_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type MetricDescriptor_FieldTerminalPathArrayOfValues struct {
	MetricDescriptor_FieldTerminalPath
	values interface{}
}

var _ MetricDescriptor_FieldPathArrayOfValues = (*MetricDescriptor_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case MetricDescriptor_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*meta.Meta) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorResourceTypes:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorLabels:
		for _, v := range fpaov.values.([][]*common.LabelDescriptor) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorMetricKind:
		for _, v := range fpaov.values.([]MetricDescriptor_MetricKind) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorValueType:
		for _, v := range fpaov.values.([]MetricDescriptor_ValueType) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorUnit:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorMetricDescriptorMetadata:
		for _, v := range fpaov.values.([]*MetricDescriptor_MetricDescriptorMetadata) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorDistributionBucketOptions:
		for _, v := range fpaov.values.([]*common.Distribution_BucketOptions) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorPromotedLabelKeySets:
		for _, v := range fpaov.values.([][]*common.LabelKeySet) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorIndexSpec:
		for _, v := range fpaov.values.([]*MetricDescriptor_IndexSpec) {
			values = append(values, v)
		}
	case MetricDescriptor_FieldPathSelectorStorageConfig:
		for _, v := range fpaov.values.([]*MetricDescriptor_StorageConfig) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*meta.Meta, bool) {
	res, ok := fpaov.values.([]*meta.Meta)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsResourceTypesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsLabelsArrayOfValues() ([][]*common.LabelDescriptor, bool) {
	res, ok := fpaov.values.([][]*common.LabelDescriptor)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsMetricKindArrayOfValues() ([]MetricDescriptor_MetricKind, bool) {
	res, ok := fpaov.values.([]MetricDescriptor_MetricKind)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsValueTypeArrayOfValues() ([]MetricDescriptor_ValueType, bool) {
	res, ok := fpaov.values.([]MetricDescriptor_ValueType)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsUnitArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsMetricDescriptorMetadataArrayOfValues() ([]*MetricDescriptor_MetricDescriptorMetadata, bool) {
	res, ok := fpaov.values.([]*MetricDescriptor_MetricDescriptorMetadata)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsDistributionBucketOptionsArrayOfValues() ([]*common.Distribution_BucketOptions, bool) {
	res, ok := fpaov.values.([]*common.Distribution_BucketOptions)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsPromotedLabelKeySetsArrayOfValues() ([][]*common.LabelKeySet, bool) {
	res, ok := fpaov.values.([][]*common.LabelKeySet)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsIndexSpecArrayOfValues() ([]*MetricDescriptor_IndexSpec, bool) {
	res, ok := fpaov.values.([]*MetricDescriptor_IndexSpec)
	return res, ok
}
func (fpaov *MetricDescriptor_FieldTerminalPathArrayOfValues) AsStorageConfigArrayOfValues() ([]*MetricDescriptor_StorageConfig, bool) {
	res, ok := fpaov.values.([]*MetricDescriptor_StorageConfig)
	return res, ok
}

type MetricDescriptor_FieldSubPathArrayOfValues struct {
	MetricDescriptor_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ MetricDescriptor_FieldPathArrayOfValues = (*MetricDescriptor_FieldSubPathArrayOfValues)(nil)

func (fpsaov *MetricDescriptor_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *MetricDescriptor_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(meta.Meta_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *MetricDescriptor_FieldSubPathArrayOfValues) AsLabelsPathArrayOfValues() (common.LabelDescriptor_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.LabelDescriptor_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *MetricDescriptor_FieldSubPathArrayOfValues) AsMetricDescriptorMetadataPathArrayOfValues() (MetricDescriptorMetricDescriptorMetadata_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(MetricDescriptorMetricDescriptorMetadata_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *MetricDescriptor_FieldSubPathArrayOfValues) AsDistributionBucketOptionsPathArrayOfValues() (common.DistributionBucketOptions_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.DistributionBucketOptions_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *MetricDescriptor_FieldSubPathArrayOfValues) AsPromotedLabelKeySetsPathArrayOfValues() (common.LabelKeySet_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.LabelKeySet_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *MetricDescriptor_FieldSubPathArrayOfValues) AsIndexSpecPathArrayOfValues() (MetricDescriptorIndexSpec_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(MetricDescriptorIndexSpec_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *MetricDescriptor_FieldSubPathArrayOfValues) AsStorageConfigPathArrayOfValues() (MetricDescriptorStorageConfig_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(MetricDescriptorStorageConfig_FieldPathArrayOfValues)
	return res, ok
}

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

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

type MetricDescriptorMetricDescriptorMetadata_FieldPathSelector int32

const (
	MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage MetricDescriptorMetricDescriptorMetadata_FieldPathSelector = 0
)

func (s MetricDescriptorMetricDescriptorMetadata_FieldPathSelector) String() string {
	switch s {
	case MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage:
		return "launch_stage"
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_MetricDescriptorMetadata: %d", s))
	}
}

func BuildMetricDescriptorMetricDescriptorMetadata_FieldPath(fp gotenobject.RawFieldPath) (MetricDescriptorMetricDescriptorMetadata_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object MetricDescriptor_MetricDescriptorMetadata")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "launch_stage", "launchStage", "launch-stage":
			return &MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath{selector: MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object MetricDescriptor_MetricDescriptorMetadata", fp)
}

func ParseMetricDescriptorMetricDescriptorMetadata_FieldPath(rawField string) (MetricDescriptorMetricDescriptorMetadata_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildMetricDescriptorMetricDescriptorMetadata_FieldPath(fp)
}

func MustParseMetricDescriptorMetricDescriptorMetadata_FieldPath(rawField string) MetricDescriptorMetricDescriptorMetadata_FieldPath {
	fp, err := ParseMetricDescriptorMetricDescriptorMetadata_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath struct {
	selector MetricDescriptorMetricDescriptorMetadata_FieldPathSelector
}

var _ MetricDescriptorMetricDescriptorMetadata_FieldPath = (*MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath)(nil)

func (fp *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath) Selector() MetricDescriptorMetricDescriptorMetadata_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage:
		return api.LaunchStage_LAUNCH_STAGE_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_MetricDescriptorMetadata: %d", fp.selector))
	}
}

func (fp *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath) ClearValue(item *MetricDescriptor_MetricDescriptorMetadata) {
	if item != nil {
		switch fp.selector {
		case MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage:
			item.LaunchStage = api.LaunchStage_LAUNCH_STAGE_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for MetricDescriptor_MetricDescriptorMetadata: %d", fp.selector))
		}
	}
}

func (fp *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*MetricDescriptor_MetricDescriptorMetadata))
}

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

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

func (fp *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath) WithIValue(value interface{}) MetricDescriptorMetricDescriptorMetadata_FieldPathValue {
	switch fp.selector {
	case MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage:
		return &MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathValue{MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath: *fp, value: value.(api.LaunchStage)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_MetricDescriptorMetadata: %d", fp.selector))
	}
}

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

func (fp *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath) WithIArrayOfValues(values interface{}) MetricDescriptorMetricDescriptorMetadata_FieldPathArrayOfValues {
	fpaov := &MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathArrayOfValues{MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath: *fp}
	switch fp.selector {
	case MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage:
		return &MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathArrayOfValues{MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath: *fp, values: values.([]api.LaunchStage)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_MetricDescriptorMetadata: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// MetricDescriptorMetricDescriptorMetadata_FieldPathValue allows storing values for MetricDescriptorMetadata fields according to their type
type MetricDescriptorMetricDescriptorMetadata_FieldPathValue interface {
	MetricDescriptorMetricDescriptorMetadata_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **MetricDescriptor_MetricDescriptorMetadata)
	CompareWith(*MetricDescriptor_MetricDescriptorMetadata) (cmp int, comparable bool)
}

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

func MustParseMetricDescriptorMetricDescriptorMetadata_FieldPathValue(pathStr, valueStr string) MetricDescriptorMetricDescriptorMetadata_FieldPathValue {
	fpv, err := ParseMetricDescriptorMetricDescriptorMetadata_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathValue struct {
	MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorMetricDescriptorMetadata_FieldPathValue = (*MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'MetricDescriptorMetadata' as interface{}
func (fpv *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathValue) AsLaunchStageValue() (api.LaunchStage, bool) {
	res, ok := fpv.value.(api.LaunchStage)
	return res, ok
}

// SetTo stores value for selected field for object MetricDescriptorMetadata
func (fpv *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathValue) SetTo(target **MetricDescriptor_MetricDescriptorMetadata) {
	if *target == nil {
		*target = new(MetricDescriptor_MetricDescriptorMetadata)
	}
	switch fpv.selector {
	case MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage:
		(*target).LaunchStage = fpv.value.(api.LaunchStage)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_MetricDescriptorMetadata: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathValue' with the value under path in 'MetricDescriptor_MetricDescriptorMetadata'.
func (fpv *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathValue) CompareWith(source *MetricDescriptor_MetricDescriptorMetadata) (int, bool) {
	switch fpv.selector {
	case MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage:
		leftValue := fpv.value.(api.LaunchStage)
		rightValue := source.GetLaunchStage()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_MetricDescriptorMetadata: %d", fpv.selector))
	}
}

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

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

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

func MustParseMetricDescriptorMetricDescriptorMetadata_FieldPathArrayItemValue(pathStr, valueStr string) MetricDescriptorMetricDescriptorMetadata_FieldPathArrayItemValue {
	fpaiv, err := ParseMetricDescriptorMetricDescriptorMetadata_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathArrayItemValue struct {
	MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorMetricDescriptorMetadata_FieldPathArrayItemValue = (*MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathArrayItemValue) GetSingle(source *MetricDescriptor_MetricDescriptorMetadata) (interface{}, bool) {
	return nil, false
}

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

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

// MetricDescriptorMetricDescriptorMetadata_FieldPathArrayOfValues allows storing slice of values for MetricDescriptorMetadata fields according to their type
type MetricDescriptorMetricDescriptorMetadata_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	MetricDescriptorMetricDescriptorMetadata_FieldPath
}

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

func MustParseMetricDescriptorMetricDescriptorMetadata_FieldPathArrayOfValues(pathStr, valuesStr string) MetricDescriptorMetricDescriptorMetadata_FieldPathArrayOfValues {
	fpaov, err := ParseMetricDescriptorMetricDescriptorMetadata_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathArrayOfValues struct {
	MetricDescriptorMetricDescriptorMetadata_FieldTerminalPath
	values interface{}
}

var _ MetricDescriptorMetricDescriptorMetadata_FieldPathArrayOfValues = (*MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case MetricDescriptorMetricDescriptorMetadata_FieldPathSelectorLaunchStage:
		for _, v := range fpaov.values.([]api.LaunchStage) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *MetricDescriptorMetricDescriptorMetadata_FieldTerminalPathArrayOfValues) AsLaunchStageArrayOfValues() ([]api.LaunchStage, bool) {
	res, ok := fpaov.values.([]api.LaunchStage)
	return res, ok
}

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

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

type MetricDescriptorIndexSpec_FieldPathSelector int32

const (
	MetricDescriptorIndexSpec_FieldPathSelectorPerResource MetricDescriptorIndexSpec_FieldPathSelector = 0
)

func (s MetricDescriptorIndexSpec_FieldPathSelector) String() string {
	switch s {
	case MetricDescriptorIndexSpec_FieldPathSelectorPerResource:
		return "per_resource"
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec: %d", s))
	}
}

func BuildMetricDescriptorIndexSpec_FieldPath(fp gotenobject.RawFieldPath) (MetricDescriptorIndexSpec_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object MetricDescriptor_IndexSpec")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "per_resource", "perResource", "per-resource":
			return &MetricDescriptorIndexSpec_FieldTerminalPath{selector: MetricDescriptorIndexSpec_FieldPathSelectorPerResource}, nil
		}
	} else {
		switch fp[0] {
		case "per_resource", "perResource", "per-resource":
			if subpath, err := BuildMetricDescriptorIndexSpecPerMonitoredResource_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &MetricDescriptorIndexSpec_FieldSubPath{selector: MetricDescriptorIndexSpec_FieldPathSelectorPerResource, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object MetricDescriptor_IndexSpec", fp)
}

func ParseMetricDescriptorIndexSpec_FieldPath(rawField string) (MetricDescriptorIndexSpec_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildMetricDescriptorIndexSpec_FieldPath(fp)
}

func MustParseMetricDescriptorIndexSpec_FieldPath(rawField string) MetricDescriptorIndexSpec_FieldPath {
	fp, err := ParseMetricDescriptorIndexSpec_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type MetricDescriptorIndexSpec_FieldTerminalPath struct {
	selector MetricDescriptorIndexSpec_FieldPathSelector
}

var _ MetricDescriptorIndexSpec_FieldPath = (*MetricDescriptorIndexSpec_FieldTerminalPath)(nil)

func (fp *MetricDescriptorIndexSpec_FieldTerminalPath) Selector() MetricDescriptorIndexSpec_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *MetricDescriptorIndexSpec_FieldTerminalPath) ClearValue(item *MetricDescriptor_IndexSpec) {
	if item != nil {
		switch fp.selector {
		case MetricDescriptorIndexSpec_FieldPathSelectorPerResource:
			item.PerResource = nil
		default:
			panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec: %d", fp.selector))
		}
	}
}

func (fp *MetricDescriptorIndexSpec_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*MetricDescriptor_IndexSpec))
}

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

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

func (fp *MetricDescriptorIndexSpec_FieldTerminalPath) WithIValue(value interface{}) MetricDescriptorIndexSpec_FieldPathValue {
	switch fp.selector {
	case MetricDescriptorIndexSpec_FieldPathSelectorPerResource:
		return &MetricDescriptorIndexSpec_FieldTerminalPathValue{MetricDescriptorIndexSpec_FieldTerminalPath: *fp, value: value.([]*MetricDescriptor_IndexSpec_PerMonitoredResource)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec: %d", fp.selector))
	}
}

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

func (fp *MetricDescriptorIndexSpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) MetricDescriptorIndexSpec_FieldPathArrayOfValues {
	fpaov := &MetricDescriptorIndexSpec_FieldTerminalPathArrayOfValues{MetricDescriptorIndexSpec_FieldTerminalPath: *fp}
	switch fp.selector {
	case MetricDescriptorIndexSpec_FieldPathSelectorPerResource:
		return &MetricDescriptorIndexSpec_FieldTerminalPathArrayOfValues{MetricDescriptorIndexSpec_FieldTerminalPath: *fp, values: values.([][]*MetricDescriptor_IndexSpec_PerMonitoredResource)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *MetricDescriptorIndexSpec_FieldTerminalPath) WithIArrayItemValue(value interface{}) MetricDescriptorIndexSpec_FieldPathArrayItemValue {
	switch fp.selector {
	case MetricDescriptorIndexSpec_FieldPathSelectorPerResource:
		return &MetricDescriptorIndexSpec_FieldTerminalPathArrayItemValue{MetricDescriptorIndexSpec_FieldTerminalPath: *fp, value: value.(*MetricDescriptor_IndexSpec_PerMonitoredResource)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec: %d", fp.selector))
	}
}

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

type MetricDescriptorIndexSpec_FieldSubPath struct {
	selector MetricDescriptorIndexSpec_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ MetricDescriptorIndexSpec_FieldPath = (*MetricDescriptorIndexSpec_FieldSubPath)(nil)

func (fps *MetricDescriptorIndexSpec_FieldSubPath) Selector() MetricDescriptorIndexSpec_FieldPathSelector {
	return fps.selector
}
func (fps *MetricDescriptorIndexSpec_FieldSubPath) AsPerResourceSubPath() (MetricDescriptorIndexSpecPerMonitoredResource_FieldPath, bool) {
	res, ok := fps.subPath.(MetricDescriptorIndexSpecPerMonitoredResource_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *MetricDescriptorIndexSpec_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*MetricDescriptor_IndexSpec))
}

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

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

func (fps *MetricDescriptorIndexSpec_FieldSubPath) WithIValue(value interface{}) MetricDescriptorIndexSpec_FieldPathValue {
	return &MetricDescriptorIndexSpec_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *MetricDescriptorIndexSpec_FieldSubPath) WithIArrayOfValues(values interface{}) MetricDescriptorIndexSpec_FieldPathArrayOfValues {
	return &MetricDescriptorIndexSpec_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *MetricDescriptorIndexSpec_FieldSubPath) WithIArrayItemValue(value interface{}) MetricDescriptorIndexSpec_FieldPathArrayItemValue {
	return &MetricDescriptorIndexSpec_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// MetricDescriptorIndexSpec_FieldPathValue allows storing values for IndexSpec fields according to their type
type MetricDescriptorIndexSpec_FieldPathValue interface {
	MetricDescriptorIndexSpec_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **MetricDescriptor_IndexSpec)
	CompareWith(*MetricDescriptor_IndexSpec) (cmp int, comparable bool)
}

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

func MustParseMetricDescriptorIndexSpec_FieldPathValue(pathStr, valueStr string) MetricDescriptorIndexSpec_FieldPathValue {
	fpv, err := ParseMetricDescriptorIndexSpec_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type MetricDescriptorIndexSpec_FieldTerminalPathValue struct {
	MetricDescriptorIndexSpec_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorIndexSpec_FieldPathValue = (*MetricDescriptorIndexSpec_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'IndexSpec' as interface{}
func (fpv *MetricDescriptorIndexSpec_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *MetricDescriptorIndexSpec_FieldTerminalPathValue) AsPerResourceValue() ([]*MetricDescriptor_IndexSpec_PerMonitoredResource, bool) {
	res, ok := fpv.value.([]*MetricDescriptor_IndexSpec_PerMonitoredResource)
	return res, ok
}

// SetTo stores value for selected field for object IndexSpec
func (fpv *MetricDescriptorIndexSpec_FieldTerminalPathValue) SetTo(target **MetricDescriptor_IndexSpec) {
	if *target == nil {
		*target = new(MetricDescriptor_IndexSpec)
	}
	switch fpv.selector {
	case MetricDescriptorIndexSpec_FieldPathSelectorPerResource:
		(*target).PerResource = fpv.value.([]*MetricDescriptor_IndexSpec_PerMonitoredResource)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec: %d", fpv.selector))
	}
}

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

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

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

type MetricDescriptorIndexSpec_FieldSubPathValue struct {
	MetricDescriptorIndexSpec_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ MetricDescriptorIndexSpec_FieldPathValue = (*MetricDescriptorIndexSpec_FieldSubPathValue)(nil)

func (fpvs *MetricDescriptorIndexSpec_FieldSubPathValue) AsPerResourcePathValue() (MetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(MetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseMetricDescriptorIndexSpec_FieldPathArrayItemValue(pathStr, valueStr string) MetricDescriptorIndexSpec_FieldPathArrayItemValue {
	fpaiv, err := ParseMetricDescriptorIndexSpec_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type MetricDescriptorIndexSpec_FieldTerminalPathArrayItemValue struct {
	MetricDescriptorIndexSpec_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorIndexSpec_FieldPathArrayItemValue = (*MetricDescriptorIndexSpec_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object MetricDescriptor_IndexSpec as interface{}
func (fpaiv *MetricDescriptorIndexSpec_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *MetricDescriptorIndexSpec_FieldTerminalPathArrayItemValue) AsPerResourceItemValue() (*MetricDescriptor_IndexSpec_PerMonitoredResource, bool) {
	res, ok := fpaiv.value.(*MetricDescriptor_IndexSpec_PerMonitoredResource)
	return res, ok
}

func (fpaiv *MetricDescriptorIndexSpec_FieldTerminalPathArrayItemValue) GetSingle(source *MetricDescriptor_IndexSpec) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'IndexSpec'
func (fpaiv *MetricDescriptorIndexSpec_FieldTerminalPathArrayItemValue) ContainsValue(source *MetricDescriptor_IndexSpec) bool {
	slice := fpaiv.MetricDescriptorIndexSpec_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 MetricDescriptorIndexSpec_FieldSubPathArrayItemValue struct {
	MetricDescriptorIndexSpec_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// MetricDescriptorIndexSpec_FieldPathArrayOfValues allows storing slice of values for IndexSpec fields according to their type
type MetricDescriptorIndexSpec_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	MetricDescriptorIndexSpec_FieldPath
}

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

func MustParseMetricDescriptorIndexSpec_FieldPathArrayOfValues(pathStr, valuesStr string) MetricDescriptorIndexSpec_FieldPathArrayOfValues {
	fpaov, err := ParseMetricDescriptorIndexSpec_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type MetricDescriptorIndexSpec_FieldTerminalPathArrayOfValues struct {
	MetricDescriptorIndexSpec_FieldTerminalPath
	values interface{}
}

var _ MetricDescriptorIndexSpec_FieldPathArrayOfValues = (*MetricDescriptorIndexSpec_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *MetricDescriptorIndexSpec_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case MetricDescriptorIndexSpec_FieldPathSelectorPerResource:
		for _, v := range fpaov.values.([][]*MetricDescriptor_IndexSpec_PerMonitoredResource) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *MetricDescriptorIndexSpec_FieldTerminalPathArrayOfValues) AsPerResourceArrayOfValues() ([][]*MetricDescriptor_IndexSpec_PerMonitoredResource, bool) {
	res, ok := fpaov.values.([][]*MetricDescriptor_IndexSpec_PerMonitoredResource)
	return res, ok
}

type MetricDescriptorIndexSpec_FieldSubPathArrayOfValues struct {
	MetricDescriptorIndexSpec_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ MetricDescriptorIndexSpec_FieldPathArrayOfValues = (*MetricDescriptorIndexSpec_FieldSubPathArrayOfValues)(nil)

func (fpsaov *MetricDescriptorIndexSpec_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *MetricDescriptorIndexSpec_FieldSubPathArrayOfValues) AsPerResourcePathArrayOfValues() (MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues)
	return res, ok
}

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

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

type MetricDescriptorStorageConfig_FieldPathSelector int32

const (
	MetricDescriptorStorageConfig_FieldPathSelectorStoreRawPoints MetricDescriptorStorageConfig_FieldPathSelector = 0
)

func (s MetricDescriptorStorageConfig_FieldPathSelector) String() string {
	switch s {
	case MetricDescriptorStorageConfig_FieldPathSelectorStoreRawPoints:
		return "store_raw_points"
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_StorageConfig: %d", s))
	}
}

func BuildMetricDescriptorStorageConfig_FieldPath(fp gotenobject.RawFieldPath) (MetricDescriptorStorageConfig_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object MetricDescriptor_StorageConfig")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "store_raw_points", "storeRawPoints", "store-raw-points":
			return &MetricDescriptorStorageConfig_FieldTerminalPath{selector: MetricDescriptorStorageConfig_FieldPathSelectorStoreRawPoints}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object MetricDescriptor_StorageConfig", fp)
}

func ParseMetricDescriptorStorageConfig_FieldPath(rawField string) (MetricDescriptorStorageConfig_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildMetricDescriptorStorageConfig_FieldPath(fp)
}

func MustParseMetricDescriptorStorageConfig_FieldPath(rawField string) MetricDescriptorStorageConfig_FieldPath {
	fp, err := ParseMetricDescriptorStorageConfig_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type MetricDescriptorStorageConfig_FieldTerminalPath struct {
	selector MetricDescriptorStorageConfig_FieldPathSelector
}

var _ MetricDescriptorStorageConfig_FieldPath = (*MetricDescriptorStorageConfig_FieldTerminalPath)(nil)

func (fp *MetricDescriptorStorageConfig_FieldTerminalPath) Selector() MetricDescriptorStorageConfig_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *MetricDescriptorStorageConfig_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case MetricDescriptorStorageConfig_FieldPathSelectorStoreRawPoints:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_StorageConfig: %d", fp.selector))
	}
}

func (fp *MetricDescriptorStorageConfig_FieldTerminalPath) ClearValue(item *MetricDescriptor_StorageConfig) {
	if item != nil {
		switch fp.selector {
		case MetricDescriptorStorageConfig_FieldPathSelectorStoreRawPoints:
			item.StoreRawPoints = false
		default:
			panic(fmt.Sprintf("Invalid selector for MetricDescriptor_StorageConfig: %d", fp.selector))
		}
	}
}

func (fp *MetricDescriptorStorageConfig_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*MetricDescriptor_StorageConfig))
}

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

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

func (fp *MetricDescriptorStorageConfig_FieldTerminalPath) WithIValue(value interface{}) MetricDescriptorStorageConfig_FieldPathValue {
	switch fp.selector {
	case MetricDescriptorStorageConfig_FieldPathSelectorStoreRawPoints:
		return &MetricDescriptorStorageConfig_FieldTerminalPathValue{MetricDescriptorStorageConfig_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_StorageConfig: %d", fp.selector))
	}
}

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

func (fp *MetricDescriptorStorageConfig_FieldTerminalPath) WithIArrayOfValues(values interface{}) MetricDescriptorStorageConfig_FieldPathArrayOfValues {
	fpaov := &MetricDescriptorStorageConfig_FieldTerminalPathArrayOfValues{MetricDescriptorStorageConfig_FieldTerminalPath: *fp}
	switch fp.selector {
	case MetricDescriptorStorageConfig_FieldPathSelectorStoreRawPoints:
		return &MetricDescriptorStorageConfig_FieldTerminalPathArrayOfValues{MetricDescriptorStorageConfig_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_StorageConfig: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// MetricDescriptorStorageConfig_FieldPathValue allows storing values for StorageConfig fields according to their type
type MetricDescriptorStorageConfig_FieldPathValue interface {
	MetricDescriptorStorageConfig_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **MetricDescriptor_StorageConfig)
	CompareWith(*MetricDescriptor_StorageConfig) (cmp int, comparable bool)
}

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

func MustParseMetricDescriptorStorageConfig_FieldPathValue(pathStr, valueStr string) MetricDescriptorStorageConfig_FieldPathValue {
	fpv, err := ParseMetricDescriptorStorageConfig_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type MetricDescriptorStorageConfig_FieldTerminalPathValue struct {
	MetricDescriptorStorageConfig_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorStorageConfig_FieldPathValue = (*MetricDescriptorStorageConfig_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'StorageConfig' as interface{}
func (fpv *MetricDescriptorStorageConfig_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *MetricDescriptorStorageConfig_FieldTerminalPathValue) AsStoreRawPointsValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object StorageConfig
func (fpv *MetricDescriptorStorageConfig_FieldTerminalPathValue) SetTo(target **MetricDescriptor_StorageConfig) {
	if *target == nil {
		*target = new(MetricDescriptor_StorageConfig)
	}
	switch fpv.selector {
	case MetricDescriptorStorageConfig_FieldPathSelectorStoreRawPoints:
		(*target).StoreRawPoints = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_StorageConfig: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'MetricDescriptorStorageConfig_FieldTerminalPathValue' with the value under path in 'MetricDescriptor_StorageConfig'.
func (fpv *MetricDescriptorStorageConfig_FieldTerminalPathValue) CompareWith(source *MetricDescriptor_StorageConfig) (int, bool) {
	switch fpv.selector {
	case MetricDescriptorStorageConfig_FieldPathSelectorStoreRawPoints:
		leftValue := fpv.value.(bool)
		rightValue := source.GetStoreRawPoints()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_StorageConfig: %d", fpv.selector))
	}
}

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

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

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

func MustParseMetricDescriptorStorageConfig_FieldPathArrayItemValue(pathStr, valueStr string) MetricDescriptorStorageConfig_FieldPathArrayItemValue {
	fpaiv, err := ParseMetricDescriptorStorageConfig_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type MetricDescriptorStorageConfig_FieldTerminalPathArrayItemValue struct {
	MetricDescriptorStorageConfig_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorStorageConfig_FieldPathArrayItemValue = (*MetricDescriptorStorageConfig_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *MetricDescriptorStorageConfig_FieldTerminalPathArrayItemValue) GetSingle(source *MetricDescriptor_StorageConfig) (interface{}, bool) {
	return nil, false
}

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

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

// MetricDescriptorStorageConfig_FieldPathArrayOfValues allows storing slice of values for StorageConfig fields according to their type
type MetricDescriptorStorageConfig_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	MetricDescriptorStorageConfig_FieldPath
}

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

func MustParseMetricDescriptorStorageConfig_FieldPathArrayOfValues(pathStr, valuesStr string) MetricDescriptorStorageConfig_FieldPathArrayOfValues {
	fpaov, err := ParseMetricDescriptorStorageConfig_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type MetricDescriptorStorageConfig_FieldTerminalPathArrayOfValues struct {
	MetricDescriptorStorageConfig_FieldTerminalPath
	values interface{}
}

var _ MetricDescriptorStorageConfig_FieldPathArrayOfValues = (*MetricDescriptorStorageConfig_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type MetricDescriptorIndexSpecIndex_FieldPathSelector int32

const (
	MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels MetricDescriptorIndexSpecIndex_FieldPathSelector = 0
	MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly      MetricDescriptorIndexSpecIndex_FieldPathSelector = 1
)

func (s MetricDescriptorIndexSpecIndex_FieldPathSelector) String() string {
	switch s {
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels:
		return "promoted_labels"
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly:
		return "write_only"
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_Index: %d", s))
	}
}

func BuildMetricDescriptorIndexSpecIndex_FieldPath(fp gotenobject.RawFieldPath) (MetricDescriptorIndexSpecIndex_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object MetricDescriptor_IndexSpec_Index")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "promoted_labels", "promotedLabels", "promoted-labels":
			return &MetricDescriptorIndexSpecIndex_FieldTerminalPath{selector: MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels}, nil
		case "write_only", "writeOnly", "write-only":
			return &MetricDescriptorIndexSpecIndex_FieldTerminalPath{selector: MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object MetricDescriptor_IndexSpec_Index", fp)
}

func ParseMetricDescriptorIndexSpecIndex_FieldPath(rawField string) (MetricDescriptorIndexSpecIndex_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildMetricDescriptorIndexSpecIndex_FieldPath(fp)
}

func MustParseMetricDescriptorIndexSpecIndex_FieldPath(rawField string) MetricDescriptorIndexSpecIndex_FieldPath {
	fp, err := ParseMetricDescriptorIndexSpecIndex_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type MetricDescriptorIndexSpecIndex_FieldTerminalPath struct {
	selector MetricDescriptorIndexSpecIndex_FieldPathSelector
}

var _ MetricDescriptorIndexSpecIndex_FieldPath = (*MetricDescriptorIndexSpecIndex_FieldTerminalPath)(nil)

func (fp *MetricDescriptorIndexSpecIndex_FieldTerminalPath) Selector() MetricDescriptorIndexSpecIndex_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *MetricDescriptorIndexSpecIndex_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels:
		return ([]string)(nil)
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_Index: %d", fp.selector))
	}
}

func (fp *MetricDescriptorIndexSpecIndex_FieldTerminalPath) ClearValue(item *MetricDescriptor_IndexSpec_Index) {
	if item != nil {
		switch fp.selector {
		case MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels:
			item.PromotedLabels = nil
		case MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly:
			item.WriteOnly = false
		default:
			panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_Index: %d", fp.selector))
		}
	}
}

func (fp *MetricDescriptorIndexSpecIndex_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*MetricDescriptor_IndexSpec_Index))
}

// IsLeaf - whether field path is holds simple value
func (fp *MetricDescriptorIndexSpecIndex_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels ||
		fp.selector == MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly
}

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

func (fp *MetricDescriptorIndexSpecIndex_FieldTerminalPath) WithIValue(value interface{}) MetricDescriptorIndexSpecIndex_FieldPathValue {
	switch fp.selector {
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels:
		return &MetricDescriptorIndexSpecIndex_FieldTerminalPathValue{MetricDescriptorIndexSpecIndex_FieldTerminalPath: *fp, value: value.([]string)}
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly:
		return &MetricDescriptorIndexSpecIndex_FieldTerminalPathValue{MetricDescriptorIndexSpecIndex_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_Index: %d", fp.selector))
	}
}

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

func (fp *MetricDescriptorIndexSpecIndex_FieldTerminalPath) WithIArrayOfValues(values interface{}) MetricDescriptorIndexSpecIndex_FieldPathArrayOfValues {
	fpaov := &MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayOfValues{MetricDescriptorIndexSpecIndex_FieldTerminalPath: *fp}
	switch fp.selector {
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels:
		return &MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayOfValues{MetricDescriptorIndexSpecIndex_FieldTerminalPath: *fp, values: values.([][]string)}
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly:
		return &MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayOfValues{MetricDescriptorIndexSpecIndex_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_Index: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *MetricDescriptorIndexSpecIndex_FieldTerminalPath) WithIArrayItemValue(value interface{}) MetricDescriptorIndexSpecIndex_FieldPathArrayItemValue {
	switch fp.selector {
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels:
		return &MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayItemValue{MetricDescriptorIndexSpecIndex_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_Index: %d", fp.selector))
	}
}

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

// MetricDescriptorIndexSpecIndex_FieldPathValue allows storing values for Index fields according to their type
type MetricDescriptorIndexSpecIndex_FieldPathValue interface {
	MetricDescriptorIndexSpecIndex_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **MetricDescriptor_IndexSpec_Index)
	CompareWith(*MetricDescriptor_IndexSpec_Index) (cmp int, comparable bool)
}

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

func MustParseMetricDescriptorIndexSpecIndex_FieldPathValue(pathStr, valueStr string) MetricDescriptorIndexSpecIndex_FieldPathValue {
	fpv, err := ParseMetricDescriptorIndexSpecIndex_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type MetricDescriptorIndexSpecIndex_FieldTerminalPathValue struct {
	MetricDescriptorIndexSpecIndex_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorIndexSpecIndex_FieldPathValue = (*MetricDescriptorIndexSpecIndex_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Index' as interface{}
func (fpv *MetricDescriptorIndexSpecIndex_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *MetricDescriptorIndexSpecIndex_FieldTerminalPathValue) AsPromotedLabelsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *MetricDescriptorIndexSpecIndex_FieldTerminalPathValue) AsWriteOnlyValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object Index
func (fpv *MetricDescriptorIndexSpecIndex_FieldTerminalPathValue) SetTo(target **MetricDescriptor_IndexSpec_Index) {
	if *target == nil {
		*target = new(MetricDescriptor_IndexSpec_Index)
	}
	switch fpv.selector {
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels:
		(*target).PromotedLabels = fpv.value.([]string)
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly:
		(*target).WriteOnly = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_Index: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseMetricDescriptorIndexSpecIndex_FieldPathArrayItemValue(pathStr, valueStr string) MetricDescriptorIndexSpecIndex_FieldPathArrayItemValue {
	fpaiv, err := ParseMetricDescriptorIndexSpecIndex_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayItemValue struct {
	MetricDescriptorIndexSpecIndex_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorIndexSpecIndex_FieldPathArrayItemValue = (*MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object MetricDescriptor_IndexSpec_Index as interface{}
func (fpaiv *MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayItemValue) AsPromotedLabelsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayItemValue) GetSingle(source *MetricDescriptor_IndexSpec_Index) (interface{}, bool) {
	return nil, false
}

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

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

// MetricDescriptorIndexSpecIndex_FieldPathArrayOfValues allows storing slice of values for Index fields according to their type
type MetricDescriptorIndexSpecIndex_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	MetricDescriptorIndexSpecIndex_FieldPath
}

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

func MustParseMetricDescriptorIndexSpecIndex_FieldPathArrayOfValues(pathStr, valuesStr string) MetricDescriptorIndexSpecIndex_FieldPathArrayOfValues {
	fpaov, err := ParseMetricDescriptorIndexSpecIndex_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayOfValues struct {
	MetricDescriptorIndexSpecIndex_FieldTerminalPath
	values interface{}
}

var _ MetricDescriptorIndexSpecIndex_FieldPathArrayOfValues = (*MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorPromotedLabels:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case MetricDescriptorIndexSpecIndex_FieldPathSelectorWriteOnly:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayOfValues) AsPromotedLabelsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *MetricDescriptorIndexSpecIndex_FieldTerminalPathArrayOfValues) AsWriteOnlyArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

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

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

type MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelector int32

const (
	MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelector = 0
	MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices  MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelector = 1
)

func (s MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelector) String() string {
	switch s {
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource:
		return "resource"
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices:
		return "indices"
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_PerMonitoredResource: %d", s))
	}
}

func BuildMetricDescriptorIndexSpecPerMonitoredResource_FieldPath(fp gotenobject.RawFieldPath) (MetricDescriptorIndexSpecPerMonitoredResource_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object MetricDescriptor_IndexSpec_PerMonitoredResource")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "resource":
			return &MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath{selector: MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource}, nil
		case "indices":
			return &MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath{selector: MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices}, nil
		}
	} else {
		switch fp[0] {
		case "indices":
			if subpath, err := BuildMetricDescriptorIndexSpecIndex_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPath{selector: MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object MetricDescriptor_IndexSpec_PerMonitoredResource", fp)
}

func ParseMetricDescriptorIndexSpecPerMonitoredResource_FieldPath(rawField string) (MetricDescriptorIndexSpecPerMonitoredResource_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildMetricDescriptorIndexSpecPerMonitoredResource_FieldPath(fp)
}

func MustParseMetricDescriptorIndexSpecPerMonitoredResource_FieldPath(rawField string) MetricDescriptorIndexSpecPerMonitoredResource_FieldPath {
	fp, err := ParseMetricDescriptorIndexSpecPerMonitoredResource_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath struct {
	selector MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelector
}

var _ MetricDescriptorIndexSpecPerMonitoredResource_FieldPath = (*MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath)(nil)

func (fp *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath) Selector() MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource:
		return (*monitored_resource_descriptor.Reference)(nil)
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices:
		return ([]*MetricDescriptor_IndexSpec_Index)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_PerMonitoredResource: %d", fp.selector))
	}
}

func (fp *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath) ClearValue(item *MetricDescriptor_IndexSpec_PerMonitoredResource) {
	if item != nil {
		switch fp.selector {
		case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource:
			item.Resource = nil
		case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices:
			item.Indices = nil
		default:
			panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_PerMonitoredResource: %d", fp.selector))
		}
	}
}

func (fp *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*MetricDescriptor_IndexSpec_PerMonitoredResource))
}

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

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

func (fp *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath) WithIValue(value interface{}) MetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue {
	switch fp.selector {
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource:
		return &MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue{MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath: *fp, value: value.(*monitored_resource_descriptor.Reference)}
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices:
		return &MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue{MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath: *fp, value: value.([]*MetricDescriptor_IndexSpec_Index)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_PerMonitoredResource: %d", fp.selector))
	}
}

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

func (fp *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath) WithIArrayOfValues(values interface{}) MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues {
	fpaov := &MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayOfValues{MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath: *fp}
	switch fp.selector {
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource:
		return &MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayOfValues{MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath: *fp, values: values.([]*monitored_resource_descriptor.Reference)}
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices:
		return &MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayOfValues{MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath: *fp, values: values.([][]*MetricDescriptor_IndexSpec_Index)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_PerMonitoredResource: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath) WithIArrayItemValue(value interface{}) MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayItemValue {
	switch fp.selector {
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices:
		return &MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayItemValue{MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath: *fp, value: value.(*MetricDescriptor_IndexSpec_Index)}
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_PerMonitoredResource: %d", fp.selector))
	}
}

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

type MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPath struct {
	selector MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ MetricDescriptorIndexSpecPerMonitoredResource_FieldPath = (*MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPath)(nil)

func (fps *MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPath) Selector() MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelector {
	return fps.selector
}
func (fps *MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPath) AsIndicesSubPath() (MetricDescriptorIndexSpecIndex_FieldPath, bool) {
	res, ok := fps.subPath.(MetricDescriptorIndexSpecIndex_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*MetricDescriptor_IndexSpec_PerMonitoredResource))
}

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

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

func (fps *MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPath) WithIValue(value interface{}) MetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue {
	return &MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPath) WithIArrayOfValues(values interface{}) MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues {
	return &MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPath) WithIArrayItemValue(value interface{}) MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayItemValue {
	return &MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// MetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue allows storing values for PerMonitoredResource fields according to their type
type MetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue interface {
	MetricDescriptorIndexSpecPerMonitoredResource_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **MetricDescriptor_IndexSpec_PerMonitoredResource)
	CompareWith(*MetricDescriptor_IndexSpec_PerMonitoredResource) (cmp int, comparable bool)
}

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

func MustParseMetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue(pathStr, valueStr string) MetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue {
	fpv, err := ParseMetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue struct {
	MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue = (*MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PerMonitoredResource' as interface{}
func (fpv *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue) AsResourceValue() (*monitored_resource_descriptor.Reference, bool) {
	res, ok := fpv.value.(*monitored_resource_descriptor.Reference)
	return res, ok
}
func (fpv *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue) AsIndicesValue() ([]*MetricDescriptor_IndexSpec_Index, bool) {
	res, ok := fpv.value.([]*MetricDescriptor_IndexSpec_Index)
	return res, ok
}

// SetTo stores value for selected field for object PerMonitoredResource
func (fpv *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue) SetTo(target **MetricDescriptor_IndexSpec_PerMonitoredResource) {
	if *target == nil {
		*target = new(MetricDescriptor_IndexSpec_PerMonitoredResource)
	}
	switch fpv.selector {
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource:
		(*target).Resource = fpv.value.(*monitored_resource_descriptor.Reference)
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices:
		(*target).Indices = fpv.value.([]*MetricDescriptor_IndexSpec_Index)
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_PerMonitoredResource: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue' with the value under path in 'MetricDescriptor_IndexSpec_PerMonitoredResource'.
func (fpv *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathValue) CompareWith(source *MetricDescriptor_IndexSpec_PerMonitoredResource) (int, bool) {
	switch fpv.selector {
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource:
		leftValue := fpv.value.(*monitored_resource_descriptor.Reference)
		rightValue := source.GetResource()
		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 MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for MetricDescriptor_IndexSpec_PerMonitoredResource: %d", fpv.selector))
	}
}

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

type MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathValue struct {
	MetricDescriptorIndexSpecPerMonitoredResource_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ MetricDescriptorIndexSpecPerMonitoredResource_FieldPathValue = (*MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathValue)(nil)

func (fpvs *MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathValue) AsIndicesPathValue() (MetricDescriptorIndexSpecIndex_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(MetricDescriptorIndexSpecIndex_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseMetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayItemValue(pathStr, valueStr string) MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayItemValue {
	fpaiv, err := ParseMetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayItemValue struct {
	MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath
	value interface{}
}

var _ MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayItemValue = (*MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object MetricDescriptor_IndexSpec_PerMonitoredResource as interface{}
func (fpaiv *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayItemValue) AsIndicesItemValue() (*MetricDescriptor_IndexSpec_Index, bool) {
	res, ok := fpaiv.value.(*MetricDescriptor_IndexSpec_Index)
	return res, ok
}

func (fpaiv *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayItemValue) GetSingle(source *MetricDescriptor_IndexSpec_PerMonitoredResource) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'PerMonitoredResource'
func (fpaiv *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayItemValue) ContainsValue(source *MetricDescriptor_IndexSpec_PerMonitoredResource) bool {
	slice := fpaiv.MetricDescriptorIndexSpecPerMonitoredResource_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 MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathArrayItemValue struct {
	MetricDescriptorIndexSpecPerMonitoredResource_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues allows storing slice of values for PerMonitoredResource fields according to their type
type MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	MetricDescriptorIndexSpecPerMonitoredResource_FieldPath
}

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

func MustParseMetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues(pathStr, valuesStr string) MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues {
	fpaov, err := ParseMetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayOfValues struct {
	MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPath
	values interface{}
}

var _ MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues = (*MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorResource:
		for _, v := range fpaov.values.([]*monitored_resource_descriptor.Reference) {
			values = append(values, v)
		}
	case MetricDescriptorIndexSpecPerMonitoredResource_FieldPathSelectorIndices:
		for _, v := range fpaov.values.([][]*MetricDescriptor_IndexSpec_Index) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*monitored_resource_descriptor.Reference, bool) {
	res, ok := fpaov.values.([]*monitored_resource_descriptor.Reference)
	return res, ok
}
func (fpaov *MetricDescriptorIndexSpecPerMonitoredResource_FieldTerminalPathArrayOfValues) AsIndicesArrayOfValues() ([][]*MetricDescriptor_IndexSpec_Index, bool) {
	res, ok := fpaov.values.([][]*MetricDescriptor_IndexSpec_Index)
	return res, ok
}

type MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathArrayOfValues struct {
	MetricDescriptorIndexSpecPerMonitoredResource_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ MetricDescriptorIndexSpecPerMonitoredResource_FieldPathArrayOfValues = (*MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathArrayOfValues)(nil)

func (fpsaov *MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *MetricDescriptorIndexSpecPerMonitoredResource_FieldSubPathArrayOfValues) AsIndicesPathArrayOfValues() (MetricDescriptorIndexSpecIndex_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(MetricDescriptorIndexSpecIndex_FieldPathArrayOfValues)
	return res, ok
}