provisioning_policy_custom.pb.fieldpath.go

// Code generated by protoc-gen-goten-object
// File: edgelq/devices/proto/v1alpha/provisioning_policy_custom.proto
// DO NOT EDIT!!!

package provisioning_policy_client

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

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

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

// proto imports
import (
	api "github.com/cloudwan/edgelq-sdk/common/api"
	device "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha/device"
	provisioning_approval_request "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha/provisioning_approval_request"
	provisioning_policy "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha/provisioning_policy"
)

// ensure the imports are used
var (
	_ = new(json.Marshaler)
	_ = new(fmt.Stringer)
	_ = reflect.DeepEqual
	_ = strings.Builder{}
	_ = time.Second

	_ = strcase.ToLowerCamel
	_ = codes.NotFound
	_ = status.Status{}
	_ = protojson.UnmarshalOptions{}
	_ = new(proto.Message)
	_ = protoregistry.GlobalTypes
	_ = fieldmaskpb.FieldMask{}

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &api.Account{}
	_ = &device.Device{}
	_ = &provisioning_approval_request.ProvisioningApprovalRequest{}
	_ = &provisioning_policy.ProvisioningPolicy{}
)

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

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

type ProvisionDeviceViaPolicyRequest_FieldPathSelector int32

const (
	ProvisionDeviceViaPolicyRequest_FieldPathSelectorName         ProvisionDeviceViaPolicyRequest_FieldPathSelector = 0
	ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus ProvisionDeviceViaPolicyRequest_FieldPathSelector = 1
)

func (s ProvisionDeviceViaPolicyRequest_FieldPathSelector) String() string {
	switch s {
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorName:
		return "name"
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
		return "device_status"
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", s))
	}
}

func BuildProvisionDeviceViaPolicyRequest_FieldPath(fp gotenobject.RawFieldPath) (ProvisionDeviceViaPolicyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ProvisionDeviceViaPolicyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &ProvisionDeviceViaPolicyRequest_FieldTerminalPath{selector: ProvisionDeviceViaPolicyRequest_FieldPathSelectorName}, nil
		case "device_status", "deviceStatus", "device-status":
			return &ProvisionDeviceViaPolicyRequest_FieldTerminalPath{selector: ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus}, nil
		}
	} else {
		switch fp[0] {
		case "device_status", "deviceStatus", "device-status":
			if subpath, err := device.BuildDeviceStatus_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ProvisionDeviceViaPolicyRequest_FieldSubPath{selector: ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ProvisionDeviceViaPolicyRequest", fp)
}

func ParseProvisionDeviceViaPolicyRequest_FieldPath(rawField string) (ProvisionDeviceViaPolicyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildProvisionDeviceViaPolicyRequest_FieldPath(fp)
}

func MustParseProvisionDeviceViaPolicyRequest_FieldPath(rawField string) ProvisionDeviceViaPolicyRequest_FieldPath {
	fp, err := ParseProvisionDeviceViaPolicyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ProvisionDeviceViaPolicyRequest_FieldTerminalPath struct {
	selector ProvisionDeviceViaPolicyRequest_FieldPathSelector
}

var _ ProvisionDeviceViaPolicyRequest_FieldPath = (*ProvisionDeviceViaPolicyRequest_FieldTerminalPath)(nil)

func (fp *ProvisionDeviceViaPolicyRequest_FieldTerminalPath) Selector() ProvisionDeviceViaPolicyRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *ProvisionDeviceViaPolicyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorName:
		return (*provisioning_policy.Reference)(nil)
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
		return (*device.Device_Status)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", fp.selector))
	}
}

func (fp *ProvisionDeviceViaPolicyRequest_FieldTerminalPath) ClearValue(item *ProvisionDeviceViaPolicyRequest) {
	if item != nil {
		switch fp.selector {
		case ProvisionDeviceViaPolicyRequest_FieldPathSelectorName:
			item.Name = nil
		case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
			item.DeviceStatus = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", fp.selector))
		}
	}
}

func (fp *ProvisionDeviceViaPolicyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ProvisionDeviceViaPolicyRequest))
}

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

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

func (fp *ProvisionDeviceViaPolicyRequest_FieldTerminalPath) WithIValue(value interface{}) ProvisionDeviceViaPolicyRequest_FieldPathValue {
	switch fp.selector {
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorName:
		return &ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue{ProvisionDeviceViaPolicyRequest_FieldTerminalPath: *fp, value: value.(*provisioning_policy.Reference)}
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
		return &ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue{ProvisionDeviceViaPolicyRequest_FieldTerminalPath: *fp, value: value.(*device.Device_Status)}
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", fp.selector))
	}
}

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

func (fp *ProvisionDeviceViaPolicyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ProvisionDeviceViaPolicyRequest_FieldPathArrayOfValues {
	fpaov := &ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayOfValues{ProvisionDeviceViaPolicyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorName:
		return &ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayOfValues{ProvisionDeviceViaPolicyRequest_FieldTerminalPath: *fp, values: values.([]*provisioning_policy.Reference)}
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
		return &ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayOfValues{ProvisionDeviceViaPolicyRequest_FieldTerminalPath: *fp, values: values.([]*device.Device_Status)}
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type ProvisionDeviceViaPolicyRequest_FieldSubPath struct {
	selector ProvisionDeviceViaPolicyRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ProvisionDeviceViaPolicyRequest_FieldPath = (*ProvisionDeviceViaPolicyRequest_FieldSubPath)(nil)

func (fps *ProvisionDeviceViaPolicyRequest_FieldSubPath) Selector() ProvisionDeviceViaPolicyRequest_FieldPathSelector {
	return fps.selector
}
func (fps *ProvisionDeviceViaPolicyRequest_FieldSubPath) AsDeviceStatusSubPath() (device.DeviceStatus_FieldPath, bool) {
	res, ok := fps.subPath.(device.DeviceStatus_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *ProvisionDeviceViaPolicyRequest_FieldSubPath) ClearValue(item *ProvisionDeviceViaPolicyRequest) {
	if item != nil {
		switch fps.selector {
		case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
			fps.subPath.ClearValueRaw(item.DeviceStatus)
		default:
			panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", fps.selector))
		}
	}
}

func (fps *ProvisionDeviceViaPolicyRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ProvisionDeviceViaPolicyRequest))
}

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

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

func (fps *ProvisionDeviceViaPolicyRequest_FieldSubPath) WithIValue(value interface{}) ProvisionDeviceViaPolicyRequest_FieldPathValue {
	return &ProvisionDeviceViaPolicyRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ProvisionDeviceViaPolicyRequest_FieldSubPath) WithIArrayOfValues(values interface{}) ProvisionDeviceViaPolicyRequest_FieldPathArrayOfValues {
	return &ProvisionDeviceViaPolicyRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ProvisionDeviceViaPolicyRequest_FieldSubPath) WithIArrayItemValue(value interface{}) ProvisionDeviceViaPolicyRequest_FieldPathArrayItemValue {
	return &ProvisionDeviceViaPolicyRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseProvisionDeviceViaPolicyRequest_FieldPathValue(pathStr, valueStr string) ProvisionDeviceViaPolicyRequest_FieldPathValue {
	fpv, err := ParseProvisionDeviceViaPolicyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue struct {
	ProvisionDeviceViaPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ ProvisionDeviceViaPolicyRequest_FieldPathValue = (*ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ProvisionDeviceViaPolicyRequest' as interface{}
func (fpv *ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue) AsNameValue() (*provisioning_policy.Reference, bool) {
	res, ok := fpv.value.(*provisioning_policy.Reference)
	return res, ok
}
func (fpv *ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue) AsDeviceStatusValue() (*device.Device_Status, bool) {
	res, ok := fpv.value.(*device.Device_Status)
	return res, ok
}

// SetTo stores value for selected field for object ProvisionDeviceViaPolicyRequest
func (fpv *ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue) SetTo(target **ProvisionDeviceViaPolicyRequest) {
	if *target == nil {
		*target = new(ProvisionDeviceViaPolicyRequest)
	}
	switch fpv.selector {
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*provisioning_policy.Reference)
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
		(*target).DeviceStatus = fpv.value.(*device.Device_Status)
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue' with the value under path in 'ProvisionDeviceViaPolicyRequest'.
func (fpv *ProvisionDeviceViaPolicyRequest_FieldTerminalPathValue) CompareWith(source *ProvisionDeviceViaPolicyRequest) (int, bool) {
	switch fpv.selector {
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*provisioning_policy.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", fpv.selector))
	}
}

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

type ProvisionDeviceViaPolicyRequest_FieldSubPathValue struct {
	ProvisionDeviceViaPolicyRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ProvisionDeviceViaPolicyRequest_FieldPathValue = (*ProvisionDeviceViaPolicyRequest_FieldSubPathValue)(nil)

func (fpvs *ProvisionDeviceViaPolicyRequest_FieldSubPathValue) AsDeviceStatusPathValue() (device.DeviceStatus_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(device.DeviceStatus_FieldPathValue)
	return res, ok
}

func (fpvs *ProvisionDeviceViaPolicyRequest_FieldSubPathValue) SetTo(target **ProvisionDeviceViaPolicyRequest) {
	if *target == nil {
		*target = new(ProvisionDeviceViaPolicyRequest)
	}
	switch fpvs.Selector() {
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
		fpvs.subPathValue.(device.DeviceStatus_FieldPathValue).SetTo(&(*target).DeviceStatus)
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *ProvisionDeviceViaPolicyRequest_FieldSubPathValue) CompareWith(source *ProvisionDeviceViaPolicyRequest) (int, bool) {
	switch fpvs.Selector() {
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
		return fpvs.subPathValue.(device.DeviceStatus_FieldPathValue).CompareWith(source.GetDeviceStatus())
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseProvisionDeviceViaPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr string) ProvisionDeviceViaPolicyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseProvisionDeviceViaPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayItemValue struct {
	ProvisionDeviceViaPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ ProvisionDeviceViaPolicyRequest_FieldPathArrayItemValue = (*ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ProvisionDeviceViaPolicyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ProvisionDeviceViaPolicyRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ProvisionDeviceViaPolicyRequest_FieldSubPathArrayItemValue) AsDeviceStatusPathItemValue() (device.DeviceStatus_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(device.DeviceStatus_FieldPathArrayItemValue)
	return res, ok
}

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

// ProvisionDeviceViaPolicyRequest_FieldPathArrayOfValues allows storing slice of values for ProvisionDeviceViaPolicyRequest fields according to their type
type ProvisionDeviceViaPolicyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ProvisionDeviceViaPolicyRequest_FieldPath
}

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

func MustParseProvisionDeviceViaPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ProvisionDeviceViaPolicyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseProvisionDeviceViaPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayOfValues struct {
	ProvisionDeviceViaPolicyRequest_FieldTerminalPath
	values interface{}
}

var _ ProvisionDeviceViaPolicyRequest_FieldPathArrayOfValues = (*ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*provisioning_policy.Reference) {
			values = append(values, v)
		}
	case ProvisionDeviceViaPolicyRequest_FieldPathSelectorDeviceStatus:
		for _, v := range fpaov.values.([]*device.Device_Status) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*provisioning_policy.Reference, bool) {
	res, ok := fpaov.values.([]*provisioning_policy.Reference)
	return res, ok
}
func (fpaov *ProvisionDeviceViaPolicyRequest_FieldTerminalPathArrayOfValues) AsDeviceStatusArrayOfValues() ([]*device.Device_Status, bool) {
	res, ok := fpaov.values.([]*device.Device_Status)
	return res, ok
}

type ProvisionDeviceViaPolicyRequest_FieldSubPathArrayOfValues struct {
	ProvisionDeviceViaPolicyRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ProvisionDeviceViaPolicyRequest_FieldPathArrayOfValues = (*ProvisionDeviceViaPolicyRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ProvisionDeviceViaPolicyRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ProvisionDeviceViaPolicyRequest_FieldSubPathArrayOfValues) AsDeviceStatusPathArrayOfValues() (device.DeviceStatus_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(device.DeviceStatus_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ProvisionDeviceViaPolicyResponse_FieldPathSelector int32

const (
	ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice         ProvisionDeviceViaPolicyResponse_FieldPathSelector = 0
	ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount ProvisionDeviceViaPolicyResponse_FieldPathSelector = 1
)

func (s ProvisionDeviceViaPolicyResponse_FieldPathSelector) String() string {
	switch s {
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
		return "device"
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
		return "service_account"
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", s))
	}
}

func BuildProvisionDeviceViaPolicyResponse_FieldPath(fp gotenobject.RawFieldPath) (ProvisionDeviceViaPolicyResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ProvisionDeviceViaPolicyResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "device":
			return &ProvisionDeviceViaPolicyResponse_FieldTerminalPath{selector: ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice}, nil
		case "service_account", "serviceAccount", "service-account":
			return &ProvisionDeviceViaPolicyResponse_FieldTerminalPath{selector: ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount}, nil
		}
	} else {
		switch fp[0] {
		case "device":
			if subpath, err := device.BuildDevice_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ProvisionDeviceViaPolicyResponse_FieldSubPath{selector: ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice, subPath: subpath}, nil
			}
		case "service_account", "serviceAccount", "service-account":
			if subpath, err := api.BuildServiceAccount_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ProvisionDeviceViaPolicyResponse_FieldSubPath{selector: ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ProvisionDeviceViaPolicyResponse", fp)
}

func ParseProvisionDeviceViaPolicyResponse_FieldPath(rawField string) (ProvisionDeviceViaPolicyResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildProvisionDeviceViaPolicyResponse_FieldPath(fp)
}

func MustParseProvisionDeviceViaPolicyResponse_FieldPath(rawField string) ProvisionDeviceViaPolicyResponse_FieldPath {
	fp, err := ParseProvisionDeviceViaPolicyResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ProvisionDeviceViaPolicyResponse_FieldTerminalPath struct {
	selector ProvisionDeviceViaPolicyResponse_FieldPathSelector
}

var _ ProvisionDeviceViaPolicyResponse_FieldPath = (*ProvisionDeviceViaPolicyResponse_FieldTerminalPath)(nil)

func (fp *ProvisionDeviceViaPolicyResponse_FieldTerminalPath) Selector() ProvisionDeviceViaPolicyResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *ProvisionDeviceViaPolicyResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
		return (*device.Device)(nil)
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
		return (*api.ServiceAccount)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", fp.selector))
	}
}

func (fp *ProvisionDeviceViaPolicyResponse_FieldTerminalPath) ClearValue(item *ProvisionDeviceViaPolicyResponse) {
	if item != nil {
		switch fp.selector {
		case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
			item.Device = nil
		case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
			item.ServiceAccount = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", fp.selector))
		}
	}
}

func (fp *ProvisionDeviceViaPolicyResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ProvisionDeviceViaPolicyResponse))
}

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

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

func (fp *ProvisionDeviceViaPolicyResponse_FieldTerminalPath) WithIValue(value interface{}) ProvisionDeviceViaPolicyResponse_FieldPathValue {
	switch fp.selector {
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
		return &ProvisionDeviceViaPolicyResponse_FieldTerminalPathValue{ProvisionDeviceViaPolicyResponse_FieldTerminalPath: *fp, value: value.(*device.Device)}
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
		return &ProvisionDeviceViaPolicyResponse_FieldTerminalPathValue{ProvisionDeviceViaPolicyResponse_FieldTerminalPath: *fp, value: value.(*api.ServiceAccount)}
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", fp.selector))
	}
}

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

func (fp *ProvisionDeviceViaPolicyResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ProvisionDeviceViaPolicyResponse_FieldPathArrayOfValues {
	fpaov := &ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayOfValues{ProvisionDeviceViaPolicyResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
		return &ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayOfValues{ProvisionDeviceViaPolicyResponse_FieldTerminalPath: *fp, values: values.([]*device.Device)}
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
		return &ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayOfValues{ProvisionDeviceViaPolicyResponse_FieldTerminalPath: *fp, values: values.([]*api.ServiceAccount)}
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type ProvisionDeviceViaPolicyResponse_FieldSubPath struct {
	selector ProvisionDeviceViaPolicyResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ProvisionDeviceViaPolicyResponse_FieldPath = (*ProvisionDeviceViaPolicyResponse_FieldSubPath)(nil)

func (fps *ProvisionDeviceViaPolicyResponse_FieldSubPath) Selector() ProvisionDeviceViaPolicyResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ProvisionDeviceViaPolicyResponse_FieldSubPath) AsDeviceSubPath() (device.Device_FieldPath, bool) {
	res, ok := fps.subPath.(device.Device_FieldPath)
	return res, ok
}
func (fps *ProvisionDeviceViaPolicyResponse_FieldSubPath) AsServiceAccountSubPath() (api.ServiceAccount_FieldPath, bool) {
	res, ok := fps.subPath.(api.ServiceAccount_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *ProvisionDeviceViaPolicyResponse_FieldSubPath) ClearValue(item *ProvisionDeviceViaPolicyResponse) {
	if item != nil {
		switch fps.selector {
		case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
			fps.subPath.ClearValueRaw(item.Device)
		case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
			fps.subPath.ClearValueRaw(item.ServiceAccount)
		default:
			panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", fps.selector))
		}
	}
}

func (fps *ProvisionDeviceViaPolicyResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ProvisionDeviceViaPolicyResponse))
}

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

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

func (fps *ProvisionDeviceViaPolicyResponse_FieldSubPath) WithIValue(value interface{}) ProvisionDeviceViaPolicyResponse_FieldPathValue {
	return &ProvisionDeviceViaPolicyResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ProvisionDeviceViaPolicyResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ProvisionDeviceViaPolicyResponse_FieldPathArrayOfValues {
	return &ProvisionDeviceViaPolicyResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ProvisionDeviceViaPolicyResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ProvisionDeviceViaPolicyResponse_FieldPathArrayItemValue {
	return &ProvisionDeviceViaPolicyResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseProvisionDeviceViaPolicyResponse_FieldPathValue(pathStr, valueStr string) ProvisionDeviceViaPolicyResponse_FieldPathValue {
	fpv, err := ParseProvisionDeviceViaPolicyResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ProvisionDeviceViaPolicyResponse_FieldTerminalPathValue struct {
	ProvisionDeviceViaPolicyResponse_FieldTerminalPath
	value interface{}
}

var _ ProvisionDeviceViaPolicyResponse_FieldPathValue = (*ProvisionDeviceViaPolicyResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ProvisionDeviceViaPolicyResponse' as interface{}
func (fpv *ProvisionDeviceViaPolicyResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ProvisionDeviceViaPolicyResponse_FieldTerminalPathValue) AsDeviceValue() (*device.Device, bool) {
	res, ok := fpv.value.(*device.Device)
	return res, ok
}
func (fpv *ProvisionDeviceViaPolicyResponse_FieldTerminalPathValue) AsServiceAccountValue() (*api.ServiceAccount, bool) {
	res, ok := fpv.value.(*api.ServiceAccount)
	return res, ok
}

// SetTo stores value for selected field for object ProvisionDeviceViaPolicyResponse
func (fpv *ProvisionDeviceViaPolicyResponse_FieldTerminalPathValue) SetTo(target **ProvisionDeviceViaPolicyResponse) {
	if *target == nil {
		*target = new(ProvisionDeviceViaPolicyResponse)
	}
	switch fpv.selector {
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
		(*target).Device = fpv.value.(*device.Device)
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
		(*target).ServiceAccount = fpv.value.(*api.ServiceAccount)
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", fpv.selector))
	}
}

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

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

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

type ProvisionDeviceViaPolicyResponse_FieldSubPathValue struct {
	ProvisionDeviceViaPolicyResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ProvisionDeviceViaPolicyResponse_FieldPathValue = (*ProvisionDeviceViaPolicyResponse_FieldSubPathValue)(nil)

func (fpvs *ProvisionDeviceViaPolicyResponse_FieldSubPathValue) AsDevicePathValue() (device.Device_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(device.Device_FieldPathValue)
	return res, ok
}
func (fpvs *ProvisionDeviceViaPolicyResponse_FieldSubPathValue) AsServiceAccountPathValue() (api.ServiceAccount_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(api.ServiceAccount_FieldPathValue)
	return res, ok
}

func (fpvs *ProvisionDeviceViaPolicyResponse_FieldSubPathValue) SetTo(target **ProvisionDeviceViaPolicyResponse) {
	if *target == nil {
		*target = new(ProvisionDeviceViaPolicyResponse)
	}
	switch fpvs.Selector() {
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
		fpvs.subPathValue.(device.Device_FieldPathValue).SetTo(&(*target).Device)
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
		fpvs.subPathValue.(api.ServiceAccount_FieldPathValue).SetTo(&(*target).ServiceAccount)
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *ProvisionDeviceViaPolicyResponse_FieldSubPathValue) CompareWith(source *ProvisionDeviceViaPolicyResponse) (int, bool) {
	switch fpvs.Selector() {
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
		return fpvs.subPathValue.(device.Device_FieldPathValue).CompareWith(source.GetDevice())
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
		return fpvs.subPathValue.(api.ServiceAccount_FieldPathValue).CompareWith(source.GetServiceAccount())
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseProvisionDeviceViaPolicyResponse_FieldPathArrayItemValue(pathStr, valueStr string) ProvisionDeviceViaPolicyResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseProvisionDeviceViaPolicyResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayItemValue struct {
	ProvisionDeviceViaPolicyResponse_FieldTerminalPath
	value interface{}
}

var _ ProvisionDeviceViaPolicyResponse_FieldPathArrayItemValue = (*ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ProvisionDeviceViaPolicyResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ProvisionDeviceViaPolicyResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ProvisionDeviceViaPolicyResponse_FieldSubPathArrayItemValue) AsDevicePathItemValue() (device.Device_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(device.Device_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ProvisionDeviceViaPolicyResponse_FieldSubPathArrayItemValue) AsServiceAccountPathItemValue() (api.ServiceAccount_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(api.ServiceAccount_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ProvisionDeviceViaPolicyResponse'
func (fpaivs *ProvisionDeviceViaPolicyResponse_FieldSubPathArrayItemValue) ContainsValue(source *ProvisionDeviceViaPolicyResponse) bool {
	switch fpaivs.Selector() {
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
		return fpaivs.subPathItemValue.(device.Device_FieldPathArrayItemValue).ContainsValue(source.GetDevice())
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
		return fpaivs.subPathItemValue.(api.ServiceAccount_FieldPathArrayItemValue).ContainsValue(source.GetServiceAccount())
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionDeviceViaPolicyResponse: %d", fpaivs.Selector()))
	}
}

// ProvisionDeviceViaPolicyResponse_FieldPathArrayOfValues allows storing slice of values for ProvisionDeviceViaPolicyResponse fields according to their type
type ProvisionDeviceViaPolicyResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ProvisionDeviceViaPolicyResponse_FieldPath
}

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

func MustParseProvisionDeviceViaPolicyResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ProvisionDeviceViaPolicyResponse_FieldPathArrayOfValues {
	fpaov, err := ParseProvisionDeviceViaPolicyResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayOfValues struct {
	ProvisionDeviceViaPolicyResponse_FieldTerminalPath
	values interface{}
}

var _ ProvisionDeviceViaPolicyResponse_FieldPathArrayOfValues = (*ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorDevice:
		for _, v := range fpaov.values.([]*device.Device) {
			values = append(values, v)
		}
	case ProvisionDeviceViaPolicyResponse_FieldPathSelectorServiceAccount:
		for _, v := range fpaov.values.([]*api.ServiceAccount) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayOfValues) AsDeviceArrayOfValues() ([]*device.Device, bool) {
	res, ok := fpaov.values.([]*device.Device)
	return res, ok
}
func (fpaov *ProvisionDeviceViaPolicyResponse_FieldTerminalPathArrayOfValues) AsServiceAccountArrayOfValues() ([]*api.ServiceAccount, bool) {
	res, ok := fpaov.values.([]*api.ServiceAccount)
	return res, ok
}

type ProvisionDeviceViaPolicyResponse_FieldSubPathArrayOfValues struct {
	ProvisionDeviceViaPolicyResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ProvisionDeviceViaPolicyResponse_FieldPathArrayOfValues = (*ProvisionDeviceViaPolicyResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ProvisionDeviceViaPolicyResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ProvisionDeviceViaPolicyResponse_FieldSubPathArrayOfValues) AsDevicePathArrayOfValues() (device.Device_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(device.Device_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ProvisionDeviceViaPolicyResponse_FieldSubPathArrayOfValues) AsServiceAccountPathArrayOfValues() (api.ServiceAccount_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(api.ServiceAccount_FieldPathArrayOfValues)
	return res, ok
}

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

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

type RequestProvisioningApprovalRequest_FieldPathSelector int32

const (
	RequestProvisioningApprovalRequest_FieldPathSelectorName RequestProvisioningApprovalRequest_FieldPathSelector = 0
)

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

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

func ParseRequestProvisioningApprovalRequest_FieldPath(rawField string) (RequestProvisioningApprovalRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRequestProvisioningApprovalRequest_FieldPath(fp)
}

func MustParseRequestProvisioningApprovalRequest_FieldPath(rawField string) RequestProvisioningApprovalRequest_FieldPath {
	fp, err := ParseRequestProvisioningApprovalRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RequestProvisioningApprovalRequest_FieldTerminalPath struct {
	selector RequestProvisioningApprovalRequest_FieldPathSelector
}

var _ RequestProvisioningApprovalRequest_FieldPath = (*RequestProvisioningApprovalRequest_FieldTerminalPath)(nil)

func (fp *RequestProvisioningApprovalRequest_FieldTerminalPath) Selector() RequestProvisioningApprovalRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *RequestProvisioningApprovalRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RequestProvisioningApprovalRequest))
}

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

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

func (fp *RequestProvisioningApprovalRequest_FieldTerminalPath) WithIValue(value interface{}) RequestProvisioningApprovalRequest_FieldPathValue {
	switch fp.selector {
	case RequestProvisioningApprovalRequest_FieldPathSelectorName:
		return &RequestProvisioningApprovalRequest_FieldTerminalPathValue{RequestProvisioningApprovalRequest_FieldTerminalPath: *fp, value: value.(*provisioning_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalRequest: %d", fp.selector))
	}
}

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

func (fp *RequestProvisioningApprovalRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) RequestProvisioningApprovalRequest_FieldPathArrayOfValues {
	fpaov := &RequestProvisioningApprovalRequest_FieldTerminalPathArrayOfValues{RequestProvisioningApprovalRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case RequestProvisioningApprovalRequest_FieldPathSelectorName:
		return &RequestProvisioningApprovalRequest_FieldTerminalPathArrayOfValues{RequestProvisioningApprovalRequest_FieldTerminalPath: *fp, values: values.([]*provisioning_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseRequestProvisioningApprovalRequest_FieldPathValue(pathStr, valueStr string) RequestProvisioningApprovalRequest_FieldPathValue {
	fpv, err := ParseRequestProvisioningApprovalRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RequestProvisioningApprovalRequest_FieldTerminalPathValue struct {
	RequestProvisioningApprovalRequest_FieldTerminalPath
	value interface{}
}

var _ RequestProvisioningApprovalRequest_FieldPathValue = (*RequestProvisioningApprovalRequest_FieldTerminalPathValue)(nil)

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

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

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

// CompareWith compares value in the 'RequestProvisioningApprovalRequest_FieldTerminalPathValue' with the value under path in 'RequestProvisioningApprovalRequest'.
func (fpv *RequestProvisioningApprovalRequest_FieldTerminalPathValue) CompareWith(source *RequestProvisioningApprovalRequest) (int, bool) {
	switch fpv.selector {
	case RequestProvisioningApprovalRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*provisioning_policy.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseRequestProvisioningApprovalRequest_FieldPathArrayItemValue(pathStr, valueStr string) RequestProvisioningApprovalRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseRequestProvisioningApprovalRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RequestProvisioningApprovalRequest_FieldTerminalPathArrayItemValue struct {
	RequestProvisioningApprovalRequest_FieldTerminalPath
	value interface{}
}

var _ RequestProvisioningApprovalRequest_FieldPathArrayItemValue = (*RequestProvisioningApprovalRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RequestProvisioningApprovalRequest_FieldTerminalPathArrayItemValue) GetSingle(source *RequestProvisioningApprovalRequest) (interface{}, bool) {
	return nil, false
}

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

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

// RequestProvisioningApprovalRequest_FieldPathArrayOfValues allows storing slice of values for RequestProvisioningApprovalRequest fields according to their type
type RequestProvisioningApprovalRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RequestProvisioningApprovalRequest_FieldPath
}

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

func MustParseRequestProvisioningApprovalRequest_FieldPathArrayOfValues(pathStr, valuesStr string) RequestProvisioningApprovalRequest_FieldPathArrayOfValues {
	fpaov, err := ParseRequestProvisioningApprovalRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RequestProvisioningApprovalRequest_FieldTerminalPathArrayOfValues struct {
	RequestProvisioningApprovalRequest_FieldTerminalPath
	values interface{}
}

var _ RequestProvisioningApprovalRequest_FieldPathArrayOfValues = (*RequestProvisioningApprovalRequest_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type RequestProvisioningApprovalResponse_FieldPathSelector int32

const (
	RequestProvisioningApprovalResponse_FieldPathSelectorRequest        RequestProvisioningApprovalResponse_FieldPathSelector = 0
	RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount RequestProvisioningApprovalResponse_FieldPathSelector = 1
)

func (s RequestProvisioningApprovalResponse_FieldPathSelector) String() string {
	switch s {
	case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
		return "request"
	case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
		return "service_account"
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", s))
	}
}

func BuildRequestProvisioningApprovalResponse_FieldPath(fp gotenobject.RawFieldPath) (RequestProvisioningApprovalResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object RequestProvisioningApprovalResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "request":
			return &RequestProvisioningApprovalResponse_FieldTerminalPath{selector: RequestProvisioningApprovalResponse_FieldPathSelectorRequest}, nil
		case "service_account", "serviceAccount", "service-account":
			return &RequestProvisioningApprovalResponse_FieldTerminalPath{selector: RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount}, nil
		}
	} else {
		switch fp[0] {
		case "request":
			if subpath, err := provisioning_approval_request.BuildProvisioningApprovalRequest_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &RequestProvisioningApprovalResponse_FieldSubPath{selector: RequestProvisioningApprovalResponse_FieldPathSelectorRequest, subPath: subpath}, nil
			}
		case "service_account", "serviceAccount", "service-account":
			if subpath, err := api.BuildServiceAccount_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &RequestProvisioningApprovalResponse_FieldSubPath{selector: RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object RequestProvisioningApprovalResponse", fp)
}

func ParseRequestProvisioningApprovalResponse_FieldPath(rawField string) (RequestProvisioningApprovalResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRequestProvisioningApprovalResponse_FieldPath(fp)
}

func MustParseRequestProvisioningApprovalResponse_FieldPath(rawField string) RequestProvisioningApprovalResponse_FieldPath {
	fp, err := ParseRequestProvisioningApprovalResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RequestProvisioningApprovalResponse_FieldTerminalPath struct {
	selector RequestProvisioningApprovalResponse_FieldPathSelector
}

var _ RequestProvisioningApprovalResponse_FieldPath = (*RequestProvisioningApprovalResponse_FieldTerminalPath)(nil)

func (fp *RequestProvisioningApprovalResponse_FieldTerminalPath) Selector() RequestProvisioningApprovalResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *RequestProvisioningApprovalResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
		return (*provisioning_approval_request.ProvisioningApprovalRequest)(nil)
	case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
		return (*api.ServiceAccount)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", fp.selector))
	}
}

func (fp *RequestProvisioningApprovalResponse_FieldTerminalPath) ClearValue(item *RequestProvisioningApprovalResponse) {
	if item != nil {
		switch fp.selector {
		case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
			item.Request = nil
		case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
			item.ServiceAccount = nil
		default:
			panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", fp.selector))
		}
	}
}

func (fp *RequestProvisioningApprovalResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RequestProvisioningApprovalResponse))
}

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

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

func (fp *RequestProvisioningApprovalResponse_FieldTerminalPath) WithIValue(value interface{}) RequestProvisioningApprovalResponse_FieldPathValue {
	switch fp.selector {
	case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
		return &RequestProvisioningApprovalResponse_FieldTerminalPathValue{RequestProvisioningApprovalResponse_FieldTerminalPath: *fp, value: value.(*provisioning_approval_request.ProvisioningApprovalRequest)}
	case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
		return &RequestProvisioningApprovalResponse_FieldTerminalPathValue{RequestProvisioningApprovalResponse_FieldTerminalPath: *fp, value: value.(*api.ServiceAccount)}
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", fp.selector))
	}
}

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

func (fp *RequestProvisioningApprovalResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) RequestProvisioningApprovalResponse_FieldPathArrayOfValues {
	fpaov := &RequestProvisioningApprovalResponse_FieldTerminalPathArrayOfValues{RequestProvisioningApprovalResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
		return &RequestProvisioningApprovalResponse_FieldTerminalPathArrayOfValues{RequestProvisioningApprovalResponse_FieldTerminalPath: *fp, values: values.([]*provisioning_approval_request.ProvisioningApprovalRequest)}
	case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
		return &RequestProvisioningApprovalResponse_FieldTerminalPathArrayOfValues{RequestProvisioningApprovalResponse_FieldTerminalPath: *fp, values: values.([]*api.ServiceAccount)}
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type RequestProvisioningApprovalResponse_FieldSubPath struct {
	selector RequestProvisioningApprovalResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ RequestProvisioningApprovalResponse_FieldPath = (*RequestProvisioningApprovalResponse_FieldSubPath)(nil)

func (fps *RequestProvisioningApprovalResponse_FieldSubPath) Selector() RequestProvisioningApprovalResponse_FieldPathSelector {
	return fps.selector
}
func (fps *RequestProvisioningApprovalResponse_FieldSubPath) AsRequestSubPath() (provisioning_approval_request.ProvisioningApprovalRequest_FieldPath, bool) {
	res, ok := fps.subPath.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPath)
	return res, ok
}
func (fps *RequestProvisioningApprovalResponse_FieldSubPath) AsServiceAccountSubPath() (api.ServiceAccount_FieldPath, bool) {
	res, ok := fps.subPath.(api.ServiceAccount_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *RequestProvisioningApprovalResponse_FieldSubPath) ClearValue(item *RequestProvisioningApprovalResponse) {
	if item != nil {
		switch fps.selector {
		case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
			fps.subPath.ClearValueRaw(item.Request)
		case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
			fps.subPath.ClearValueRaw(item.ServiceAccount)
		default:
			panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", fps.selector))
		}
	}
}

func (fps *RequestProvisioningApprovalResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*RequestProvisioningApprovalResponse))
}

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

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

func (fps *RequestProvisioningApprovalResponse_FieldSubPath) WithIValue(value interface{}) RequestProvisioningApprovalResponse_FieldPathValue {
	return &RequestProvisioningApprovalResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *RequestProvisioningApprovalResponse_FieldSubPath) WithIArrayOfValues(values interface{}) RequestProvisioningApprovalResponse_FieldPathArrayOfValues {
	return &RequestProvisioningApprovalResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *RequestProvisioningApprovalResponse_FieldSubPath) WithIArrayItemValue(value interface{}) RequestProvisioningApprovalResponse_FieldPathArrayItemValue {
	return &RequestProvisioningApprovalResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseRequestProvisioningApprovalResponse_FieldPathValue(pathStr, valueStr string) RequestProvisioningApprovalResponse_FieldPathValue {
	fpv, err := ParseRequestProvisioningApprovalResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RequestProvisioningApprovalResponse_FieldTerminalPathValue struct {
	RequestProvisioningApprovalResponse_FieldTerminalPath
	value interface{}
}

var _ RequestProvisioningApprovalResponse_FieldPathValue = (*RequestProvisioningApprovalResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RequestProvisioningApprovalResponse' as interface{}
func (fpv *RequestProvisioningApprovalResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *RequestProvisioningApprovalResponse_FieldTerminalPathValue) AsRequestValue() (*provisioning_approval_request.ProvisioningApprovalRequest, bool) {
	res, ok := fpv.value.(*provisioning_approval_request.ProvisioningApprovalRequest)
	return res, ok
}
func (fpv *RequestProvisioningApprovalResponse_FieldTerminalPathValue) AsServiceAccountValue() (*api.ServiceAccount, bool) {
	res, ok := fpv.value.(*api.ServiceAccount)
	return res, ok
}

// SetTo stores value for selected field for object RequestProvisioningApprovalResponse
func (fpv *RequestProvisioningApprovalResponse_FieldTerminalPathValue) SetTo(target **RequestProvisioningApprovalResponse) {
	if *target == nil {
		*target = new(RequestProvisioningApprovalResponse)
	}
	switch fpv.selector {
	case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
		(*target).Request = fpv.value.(*provisioning_approval_request.ProvisioningApprovalRequest)
	case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
		(*target).ServiceAccount = fpv.value.(*api.ServiceAccount)
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", fpv.selector))
	}
}

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

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

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

type RequestProvisioningApprovalResponse_FieldSubPathValue struct {
	RequestProvisioningApprovalResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ RequestProvisioningApprovalResponse_FieldPathValue = (*RequestProvisioningApprovalResponse_FieldSubPathValue)(nil)

func (fpvs *RequestProvisioningApprovalResponse_FieldSubPathValue) AsRequestPathValue() (provisioning_approval_request.ProvisioningApprovalRequest_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPathValue)
	return res, ok
}
func (fpvs *RequestProvisioningApprovalResponse_FieldSubPathValue) AsServiceAccountPathValue() (api.ServiceAccount_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(api.ServiceAccount_FieldPathValue)
	return res, ok
}

func (fpvs *RequestProvisioningApprovalResponse_FieldSubPathValue) SetTo(target **RequestProvisioningApprovalResponse) {
	if *target == nil {
		*target = new(RequestProvisioningApprovalResponse)
	}
	switch fpvs.Selector() {
	case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
		fpvs.subPathValue.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPathValue).SetTo(&(*target).Request)
	case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
		fpvs.subPathValue.(api.ServiceAccount_FieldPathValue).SetTo(&(*target).ServiceAccount)
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *RequestProvisioningApprovalResponse_FieldSubPathValue) CompareWith(source *RequestProvisioningApprovalResponse) (int, bool) {
	switch fpvs.Selector() {
	case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
		return fpvs.subPathValue.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPathValue).CompareWith(source.GetRequest())
	case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
		return fpvs.subPathValue.(api.ServiceAccount_FieldPathValue).CompareWith(source.GetServiceAccount())
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseRequestProvisioningApprovalResponse_FieldPathArrayItemValue(pathStr, valueStr string) RequestProvisioningApprovalResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseRequestProvisioningApprovalResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RequestProvisioningApprovalResponse_FieldTerminalPathArrayItemValue struct {
	RequestProvisioningApprovalResponse_FieldTerminalPath
	value interface{}
}

var _ RequestProvisioningApprovalResponse_FieldPathArrayItemValue = (*RequestProvisioningApprovalResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RequestProvisioningApprovalResponse_FieldTerminalPathArrayItemValue) GetSingle(source *RequestProvisioningApprovalResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *RequestProvisioningApprovalResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *RequestProvisioningApprovalResponse_FieldSubPathArrayItemValue) AsRequestPathItemValue() (provisioning_approval_request.ProvisioningApprovalRequest_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *RequestProvisioningApprovalResponse_FieldSubPathArrayItemValue) AsServiceAccountPathItemValue() (api.ServiceAccount_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(api.ServiceAccount_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'RequestProvisioningApprovalResponse'
func (fpaivs *RequestProvisioningApprovalResponse_FieldSubPathArrayItemValue) ContainsValue(source *RequestProvisioningApprovalResponse) bool {
	switch fpaivs.Selector() {
	case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
		return fpaivs.subPathItemValue.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPathArrayItemValue).ContainsValue(source.GetRequest())
	case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
		return fpaivs.subPathItemValue.(api.ServiceAccount_FieldPathArrayItemValue).ContainsValue(source.GetServiceAccount())
	default:
		panic(fmt.Sprintf("Invalid selector for RequestProvisioningApprovalResponse: %d", fpaivs.Selector()))
	}
}

// RequestProvisioningApprovalResponse_FieldPathArrayOfValues allows storing slice of values for RequestProvisioningApprovalResponse fields according to their type
type RequestProvisioningApprovalResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RequestProvisioningApprovalResponse_FieldPath
}

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

func MustParseRequestProvisioningApprovalResponse_FieldPathArrayOfValues(pathStr, valuesStr string) RequestProvisioningApprovalResponse_FieldPathArrayOfValues {
	fpaov, err := ParseRequestProvisioningApprovalResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RequestProvisioningApprovalResponse_FieldTerminalPathArrayOfValues struct {
	RequestProvisioningApprovalResponse_FieldTerminalPath
	values interface{}
}

var _ RequestProvisioningApprovalResponse_FieldPathArrayOfValues = (*RequestProvisioningApprovalResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *RequestProvisioningApprovalResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case RequestProvisioningApprovalResponse_FieldPathSelectorRequest:
		for _, v := range fpaov.values.([]*provisioning_approval_request.ProvisioningApprovalRequest) {
			values = append(values, v)
		}
	case RequestProvisioningApprovalResponse_FieldPathSelectorServiceAccount:
		for _, v := range fpaov.values.([]*api.ServiceAccount) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *RequestProvisioningApprovalResponse_FieldTerminalPathArrayOfValues) AsRequestArrayOfValues() ([]*provisioning_approval_request.ProvisioningApprovalRequest, bool) {
	res, ok := fpaov.values.([]*provisioning_approval_request.ProvisioningApprovalRequest)
	return res, ok
}
func (fpaov *RequestProvisioningApprovalResponse_FieldTerminalPathArrayOfValues) AsServiceAccountArrayOfValues() ([]*api.ServiceAccount, bool) {
	res, ok := fpaov.values.([]*api.ServiceAccount)
	return res, ok
}

type RequestProvisioningApprovalResponse_FieldSubPathArrayOfValues struct {
	RequestProvisioningApprovalResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ RequestProvisioningApprovalResponse_FieldPathArrayOfValues = (*RequestProvisioningApprovalResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *RequestProvisioningApprovalResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *RequestProvisioningApprovalResponse_FieldSubPathArrayOfValues) AsRequestPathArrayOfValues() (provisioning_approval_request.ProvisioningApprovalRequest_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(provisioning_approval_request.ProvisioningApprovalRequest_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *RequestProvisioningApprovalResponse_FieldSubPathArrayOfValues) AsServiceAccountPathArrayOfValues() (api.ServiceAccount_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(api.ServiceAccount_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathSelector int32

const (
	ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathSelectorName ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathSelector = 0
)

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

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

func ParseProvisionServiceAccountToProvisioningPolicyRequest_FieldPath(rawField string) (ProvisionServiceAccountToProvisioningPolicyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildProvisionServiceAccountToProvisioningPolicyRequest_FieldPath(fp)
}

func MustParseProvisionServiceAccountToProvisioningPolicyRequest_FieldPath(rawField string) ProvisionServiceAccountToProvisioningPolicyRequest_FieldPath {
	fp, err := ParseProvisionServiceAccountToProvisioningPolicyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath struct {
	selector ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathSelector
}

var _ ProvisionServiceAccountToProvisioningPolicyRequest_FieldPath = (*ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath)(nil)

func (fp *ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath) Selector() ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ProvisionServiceAccountToProvisioningPolicyRequest))
}

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

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

func (fp *ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath) WithIValue(value interface{}) ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathValue {
	switch fp.selector {
	case ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathSelectorName:
		return &ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathValue{ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath: *fp, value: value.(*provisioning_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyRequest: %d", fp.selector))
	}
}

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

func (fp *ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayOfValues {
	fpaov := &ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathArrayOfValues{ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathSelectorName:
		return &ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathArrayOfValues{ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath: *fp, values: values.([]*provisioning_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseProvisionServiceAccountToProvisioningPolicyRequest_FieldPathValue(pathStr, valueStr string) ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathValue {
	fpv, err := ParseProvisionServiceAccountToProvisioningPolicyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathValue struct {
	ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathValue = (*ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathValue)(nil)

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

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

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

// CompareWith compares value in the 'ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathValue' with the value under path in 'ProvisionServiceAccountToProvisioningPolicyRequest'.
func (fpv *ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathValue) CompareWith(source *ProvisionServiceAccountToProvisioningPolicyRequest) (int, bool) {
	switch fpv.selector {
	case ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*provisioning_policy.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr string) ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathArrayItemValue struct {
	ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayItemValue = (*ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ProvisionServiceAccountToProvisioningPolicyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayOfValues allows storing slice of values for ProvisionServiceAccountToProvisioningPolicyRequest fields according to their type
type ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ProvisionServiceAccountToProvisioningPolicyRequest_FieldPath
}

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

func MustParseProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathArrayOfValues struct {
	ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPath
	values interface{}
}

var _ ProvisionServiceAccountToProvisioningPolicyRequest_FieldPathArrayOfValues = (*ProvisionServiceAccountToProvisioningPolicyRequest_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelector int32

const (
	ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelector = 0
)

func (s ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelector) String() string {
	switch s {
	case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
		return "service_account"
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyResponse: %d", s))
	}
}

func BuildProvisionServiceAccountToProvisioningPolicyResponse_FieldPath(fp gotenobject.RawFieldPath) (ProvisionServiceAccountToProvisioningPolicyResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ProvisionServiceAccountToProvisioningPolicyResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service_account", "serviceAccount", "service-account":
			return &ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath{selector: ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount}, nil
		}
	} else {
		switch fp[0] {
		case "service_account", "serviceAccount", "service-account":
			if subpath, err := api.BuildServiceAccount_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath{selector: ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ProvisionServiceAccountToProvisioningPolicyResponse", fp)
}

func ParseProvisionServiceAccountToProvisioningPolicyResponse_FieldPath(rawField string) (ProvisionServiceAccountToProvisioningPolicyResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildProvisionServiceAccountToProvisioningPolicyResponse_FieldPath(fp)
}

func MustParseProvisionServiceAccountToProvisioningPolicyResponse_FieldPath(rawField string) ProvisionServiceAccountToProvisioningPolicyResponse_FieldPath {
	fp, err := ParseProvisionServiceAccountToProvisioningPolicyResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath struct {
	selector ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelector
}

var _ ProvisionServiceAccountToProvisioningPolicyResponse_FieldPath = (*ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath)(nil)

func (fp *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath) Selector() ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
		return (*api.ServiceAccount)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyResponse: %d", fp.selector))
	}
}

func (fp *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath) ClearValue(item *ProvisionServiceAccountToProvisioningPolicyResponse) {
	if item != nil {
		switch fp.selector {
		case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
			item.ServiceAccount = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyResponse: %d", fp.selector))
		}
	}
}

func (fp *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ProvisionServiceAccountToProvisioningPolicyResponse))
}

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

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

func (fp *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath) WithIValue(value interface{}) ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathValue {
	switch fp.selector {
	case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
		return &ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathValue{ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath: *fp, value: value.(*api.ServiceAccount)}
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyResponse: %d", fp.selector))
	}
}

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

func (fp *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayOfValues {
	fpaov := &ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathArrayOfValues{ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
		return &ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathArrayOfValues{ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath: *fp, values: values.([]*api.ServiceAccount)}
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath struct {
	selector ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ProvisionServiceAccountToProvisioningPolicyResponse_FieldPath = (*ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath)(nil)

func (fps *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath) Selector() ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath) AsServiceAccountSubPath() (api.ServiceAccount_FieldPath, bool) {
	res, ok := fps.subPath.(api.ServiceAccount_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath) ClearValue(item *ProvisionServiceAccountToProvisioningPolicyResponse) {
	if item != nil {
		switch fps.selector {
		case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
			fps.subPath.ClearValueRaw(item.ServiceAccount)
		default:
			panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyResponse: %d", fps.selector))
		}
	}
}

func (fps *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ProvisionServiceAccountToProvisioningPolicyResponse))
}

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

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

func (fps *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath) WithIValue(value interface{}) ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathValue {
	return &ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayOfValues {
	return &ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayItemValue {
	return &ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseProvisionServiceAccountToProvisioningPolicyResponse_FieldPathValue(pathStr, valueStr string) ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathValue {
	fpv, err := ParseProvisionServiceAccountToProvisioningPolicyResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathValue struct {
	ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath
	value interface{}
}

var _ ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathValue = (*ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ProvisionServiceAccountToProvisioningPolicyResponse' as interface{}
func (fpv *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathValue) AsServiceAccountValue() (*api.ServiceAccount, bool) {
	res, ok := fpv.value.(*api.ServiceAccount)
	return res, ok
}

// SetTo stores value for selected field for object ProvisionServiceAccountToProvisioningPolicyResponse
func (fpv *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathValue) SetTo(target **ProvisionServiceAccountToProvisioningPolicyResponse) {
	if *target == nil {
		*target = new(ProvisionServiceAccountToProvisioningPolicyResponse)
	}
	switch fpv.selector {
	case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
		(*target).ServiceAccount = fpv.value.(*api.ServiceAccount)
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyResponse: %d", fpv.selector))
	}
}

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

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

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

type ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathValue struct {
	ProvisionServiceAccountToProvisioningPolicyResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathValue = (*ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathValue)(nil)

func (fpvs *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathValue) AsServiceAccountPathValue() (api.ServiceAccount_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(api.ServiceAccount_FieldPathValue)
	return res, ok
}

func (fpvs *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathValue) SetTo(target **ProvisionServiceAccountToProvisioningPolicyResponse) {
	if *target == nil {
		*target = new(ProvisionServiceAccountToProvisioningPolicyResponse)
	}
	switch fpvs.Selector() {
	case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
		fpvs.subPathValue.(api.ServiceAccount_FieldPathValue).SetTo(&(*target).ServiceAccount)
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyResponse: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathValue) CompareWith(source *ProvisionServiceAccountToProvisioningPolicyResponse) (int, bool) {
	switch fpvs.Selector() {
	case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
		return fpvs.subPathValue.(api.ServiceAccount_FieldPathValue).CompareWith(source.GetServiceAccount())
	default:
		panic(fmt.Sprintf("Invalid selector for ProvisionServiceAccountToProvisioningPolicyResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayItemValue(pathStr, valueStr string) ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathArrayItemValue struct {
	ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath
	value interface{}
}

var _ ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayItemValue = (*ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ProvisionServiceAccountToProvisioningPolicyResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathArrayItemValue) AsServiceAccountPathItemValue() (api.ServiceAccount_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(api.ServiceAccount_FieldPathArrayItemValue)
	return res, ok
}

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

// ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayOfValues allows storing slice of values for ProvisionServiceAccountToProvisioningPolicyResponse fields according to their type
type ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ProvisionServiceAccountToProvisioningPolicyResponse_FieldPath
}

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

func MustParseProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayOfValues {
	fpaov, err := ParseProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathArrayOfValues struct {
	ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPath
	values interface{}
}

var _ ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayOfValues = (*ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathSelectorServiceAccount:
		for _, v := range fpaov.values.([]*api.ServiceAccount) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ProvisionServiceAccountToProvisioningPolicyResponse_FieldTerminalPathArrayOfValues) AsServiceAccountArrayOfValues() ([]*api.ServiceAccount, bool) {
	res, ok := fpaov.values.([]*api.ServiceAccount)
	return res, ok
}

type ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathArrayOfValues struct {
	ProvisionServiceAccountToProvisioningPolicyResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ProvisionServiceAccountToProvisioningPolicyResponse_FieldPathArrayOfValues = (*ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ProvisionServiceAccountToProvisioningPolicyResponse_FieldSubPathArrayOfValues) AsServiceAccountPathArrayOfValues() (api.ServiceAccount_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(api.ServiceAccount_FieldPathArrayOfValues)
	return res, ok
}

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

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

type RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathSelector int32

const (
	RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathSelectorName RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathSelector = 0
)

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

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

func ParseRemoveServiceAccountFromProvisioningPolicyRequest_FieldPath(rawField string) (RemoveServiceAccountFromProvisioningPolicyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRemoveServiceAccountFromProvisioningPolicyRequest_FieldPath(fp)
}

func MustParseRemoveServiceAccountFromProvisioningPolicyRequest_FieldPath(rawField string) RemoveServiceAccountFromProvisioningPolicyRequest_FieldPath {
	fp, err := ParseRemoveServiceAccountFromProvisioningPolicyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath struct {
	selector RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathSelector
}

var _ RemoveServiceAccountFromProvisioningPolicyRequest_FieldPath = (*RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath)(nil)

func (fp *RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath) Selector() RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RemoveServiceAccountFromProvisioningPolicyRequest))
}

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

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

func (fp *RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath) WithIValue(value interface{}) RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathValue {
	switch fp.selector {
	case RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathSelectorName:
		return &RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathValue{RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath: *fp, value: value.(*provisioning_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for RemoveServiceAccountFromProvisioningPolicyRequest: %d", fp.selector))
	}
}

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

func (fp *RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayOfValues {
	fpaov := &RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathArrayOfValues{RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathSelectorName:
		return &RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathArrayOfValues{RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath: *fp, values: values.([]*provisioning_policy.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for RemoveServiceAccountFromProvisioningPolicyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseRemoveServiceAccountFromProvisioningPolicyRequest_FieldPathValue(pathStr, valueStr string) RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathValue {
	fpv, err := ParseRemoveServiceAccountFromProvisioningPolicyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathValue struct {
	RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathValue = (*RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathValue)(nil)

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

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

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

// CompareWith compares value in the 'RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathValue' with the value under path in 'RemoveServiceAccountFromProvisioningPolicyRequest'.
func (fpv *RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathValue) CompareWith(source *RemoveServiceAccountFromProvisioningPolicyRequest) (int, bool) {
	switch fpv.selector {
	case RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*provisioning_policy.Reference)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for RemoveServiceAccountFromProvisioningPolicyRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseRemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr string) RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseRemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathArrayItemValue struct {
	RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath
	value interface{}
}

var _ RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayItemValue = (*RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *RemoveServiceAccountFromProvisioningPolicyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayOfValues allows storing slice of values for RemoveServiceAccountFromProvisioningPolicyRequest fields according to their type
type RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RemoveServiceAccountFromProvisioningPolicyRequest_FieldPath
}

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

func MustParseRemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseRemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathArrayOfValues struct {
	RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPath
	values interface{}
}

var _ RemoveServiceAccountFromProvisioningPolicyRequest_FieldPathArrayOfValues = (*RemoveServiceAccountFromProvisioningPolicyRequest_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelector int32

const (
	RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelectorRemoved RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelector = 0
)

func (s RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelector) String() string {
	switch s {
	case RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelectorRemoved:
		return "removed"
	default:
		panic(fmt.Sprintf("Invalid selector for RemoveServiceAccountFromProvisioningPolicyResponse: %d", s))
	}
}

func BuildRemoveServiceAccountFromProvisioningPolicyResponse_FieldPath(fp gotenobject.RawFieldPath) (RemoveServiceAccountFromProvisioningPolicyResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object RemoveServiceAccountFromProvisioningPolicyResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "removed":
			return &RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath{selector: RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelectorRemoved}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object RemoveServiceAccountFromProvisioningPolicyResponse", fp)
}

func ParseRemoveServiceAccountFromProvisioningPolicyResponse_FieldPath(rawField string) (RemoveServiceAccountFromProvisioningPolicyResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRemoveServiceAccountFromProvisioningPolicyResponse_FieldPath(fp)
}

func MustParseRemoveServiceAccountFromProvisioningPolicyResponse_FieldPath(rawField string) RemoveServiceAccountFromProvisioningPolicyResponse_FieldPath {
	fp, err := ParseRemoveServiceAccountFromProvisioningPolicyResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath struct {
	selector RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelector
}

var _ RemoveServiceAccountFromProvisioningPolicyResponse_FieldPath = (*RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath)(nil)

func (fp *RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath) Selector() RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath) ClearValue(item *RemoveServiceAccountFromProvisioningPolicyResponse) {
	if item != nil {
		switch fp.selector {
		case RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelectorRemoved:
			item.Removed = false
		default:
			panic(fmt.Sprintf("Invalid selector for RemoveServiceAccountFromProvisioningPolicyResponse: %d", fp.selector))
		}
	}
}

func (fp *RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RemoveServiceAccountFromProvisioningPolicyResponse))
}

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

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

func (fp *RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath) WithIValue(value interface{}) RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathValue {
	switch fp.selector {
	case RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelectorRemoved:
		return &RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathValue{RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for RemoveServiceAccountFromProvisioningPolicyResponse: %d", fp.selector))
	}
}

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

func (fp *RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayOfValues {
	fpaov := &RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathArrayOfValues{RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelectorRemoved:
		return &RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathArrayOfValues{RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for RemoveServiceAccountFromProvisioningPolicyResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseRemoveServiceAccountFromProvisioningPolicyResponse_FieldPathValue(pathStr, valueStr string) RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathValue {
	fpv, err := ParseRemoveServiceAccountFromProvisioningPolicyResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathValue struct {
	RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath
	value interface{}
}

var _ RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathValue = (*RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object RemoveServiceAccountFromProvisioningPolicyResponse
func (fpv *RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathValue) SetTo(target **RemoveServiceAccountFromProvisioningPolicyResponse) {
	if *target == nil {
		*target = new(RemoveServiceAccountFromProvisioningPolicyResponse)
	}
	switch fpv.selector {
	case RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathSelectorRemoved:
		(*target).Removed = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for RemoveServiceAccountFromProvisioningPolicyResponse: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseRemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayItemValue(pathStr, valueStr string) RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseRemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathArrayItemValue struct {
	RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath
	value interface{}
}

var _ RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayItemValue = (*RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathArrayItemValue) GetSingle(source *RemoveServiceAccountFromProvisioningPolicyResponse) (interface{}, bool) {
	return nil, false
}

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

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

// RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayOfValues allows storing slice of values for RemoveServiceAccountFromProvisioningPolicyResponse fields according to their type
type RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RemoveServiceAccountFromProvisioningPolicyResponse_FieldPath
}

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

func MustParseRemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayOfValues(pathStr, valuesStr string) RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayOfValues {
	fpaov, err := ParseRemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathArrayOfValues struct {
	RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPath
	values interface{}
}

var _ RemoveServiceAccountFromProvisioningPolicyResponse_FieldPathArrayOfValues = (*RemoveServiceAccountFromProvisioningPolicyResponse_FieldTerminalPathArrayOfValues)(nil)

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