plan_assignment_request.pb.fieldpath.go

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

package plan_assignment_request

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 (
	ntt_meta "github.com/cloudwan/edgelq-sdk/common/types/meta"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	common "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/common"
	plan "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/plan"
	plan_assignment "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/plan_assignment"
	meta_service "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/service"
)

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

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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &ntt_meta.Meta{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &common.Allowance{}
	_ = &plan.Plan{}
	_ = &plan_assignment.PlanAssignment{}
	_ = &meta_service.Service{}
)

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

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

type PlanAssignmentRequest_FieldPathSelector int32

const (
	PlanAssignmentRequest_FieldPathSelectorName     PlanAssignmentRequest_FieldPathSelector = 0
	PlanAssignmentRequest_FieldPathSelectorRequest  PlanAssignmentRequest_FieldPathSelector = 1
	PlanAssignmentRequest_FieldPathSelectorService  PlanAssignmentRequest_FieldPathSelector = 2
	PlanAssignmentRequest_FieldPathSelectorApprover PlanAssignmentRequest_FieldPathSelector = 3
	PlanAssignmentRequest_FieldPathSelectorStatus   PlanAssignmentRequest_FieldPathSelector = 4
	PlanAssignmentRequest_FieldPathSelectorMetadata PlanAssignmentRequest_FieldPathSelector = 5
)

func (s PlanAssignmentRequest_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequest_FieldPathSelectorName:
		return "name"
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return "request"
	case PlanAssignmentRequest_FieldPathSelectorService:
		return "service"
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		return "approver"
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return "status"
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		return "metadata"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", s))
	}
}

func BuildPlanAssignmentRequest_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorName}, nil
		case "request":
			return &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorRequest}, nil
		case "service":
			return &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorService}, nil
		case "approver":
			return &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorApprover}, nil
		case "status":
			return &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorStatus}, nil
		case "metadata":
			return &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorMetadata}, nil
		}
	} else {
		switch fp[0] {
		case "request":
			if subpath, err := BuildPlanAssignmentRequestRequest_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequest_FieldSubPath{selector: PlanAssignmentRequest_FieldPathSelectorRequest, subPath: subpath}, nil
			}
		case "status":
			if subpath, err := BuildPlanAssignmentRequestStatus_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequest_FieldSubPath{selector: PlanAssignmentRequest_FieldPathSelectorStatus, subPath: subpath}, nil
			}
		case "metadata":
			if subpath, err := ntt_meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequest_FieldSubPath{selector: PlanAssignmentRequest_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest", fp)
}

func ParsePlanAssignmentRequest_FieldPath(rawField string) (PlanAssignmentRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequest_FieldPath(fp)
}

func MustParsePlanAssignmentRequest_FieldPath(rawField string) PlanAssignmentRequest_FieldPath {
	fp, err := ParsePlanAssignmentRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequest_FieldTerminalPath struct {
	selector PlanAssignmentRequest_FieldPathSelector
}

var _ PlanAssignmentRequest_FieldPath = (*PlanAssignmentRequest_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequest_FieldTerminalPath) Selector() PlanAssignmentRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PlanAssignmentRequest
func (fp *PlanAssignmentRequest_FieldTerminalPath) Get(source *PlanAssignmentRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PlanAssignmentRequest_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case PlanAssignmentRequest_FieldPathSelectorRequest:
			if source.Request != nil {
				values = append(values, source.Request)
			}
		case PlanAssignmentRequest_FieldPathSelectorService:
			if source.Service != nil {
				values = append(values, source.Service)
			}
		case PlanAssignmentRequest_FieldPathSelectorApprover:
			if source.Approver != nil {
				values = append(values, source.Approver)
			}
		case PlanAssignmentRequest_FieldPathSelectorStatus:
			if source.Status != nil {
				values = append(values, source.Status)
			}
		case PlanAssignmentRequest_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PlanAssignmentRequest
func (fp *PlanAssignmentRequest_FieldTerminalPath) GetSingle(source *PlanAssignmentRequest) (interface{}, bool) {
	switch fp.selector {
	case PlanAssignmentRequest_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		res := source.GetRequest()
		return res, res != nil
	case PlanAssignmentRequest_FieldPathSelectorService:
		res := source.GetService()
		return res, res != nil
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		res := source.GetApprover()
		return res, res != nil
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		res := source.GetStatus()
		return res, res != nil
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PlanAssignmentRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PlanAssignmentRequest_FieldPathSelectorName:
		return (*Name)(nil)
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return (*PlanAssignmentRequest_Request)(nil)
	case PlanAssignmentRequest_FieldPathSelectorService:
		return (*meta_service.Reference)(nil)
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		return (*iam_organization.Reference)(nil)
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return (*PlanAssignmentRequest_Status)(nil)
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		return (*ntt_meta.Meta)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fp.selector))
	}
}

func (fp *PlanAssignmentRequest_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequest_FieldPathSelectorName:
			item.Name = nil
		case PlanAssignmentRequest_FieldPathSelectorRequest:
			item.Request = nil
		case PlanAssignmentRequest_FieldPathSelectorService:
			item.Service = nil
		case PlanAssignmentRequest_FieldPathSelectorApprover:
			item.Approver = nil
		case PlanAssignmentRequest_FieldPathSelectorStatus:
			item.Status = nil
		case PlanAssignmentRequest_FieldPathSelectorMetadata:
			item.Metadata = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *PlanAssignmentRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PlanAssignmentRequest_FieldPathSelectorName ||
		fp.selector == PlanAssignmentRequest_FieldPathSelectorService ||
		fp.selector == PlanAssignmentRequest_FieldPathSelectorApprover
}

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

func (fp *PlanAssignmentRequest_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequest_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequest_FieldPathSelectorName:
		return &PlanAssignmentRequest_FieldTerminalPathValue{PlanAssignmentRequest_FieldTerminalPath: *fp, value: value.(*Name)}
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return &PlanAssignmentRequest_FieldTerminalPathValue{PlanAssignmentRequest_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_Request)}
	case PlanAssignmentRequest_FieldPathSelectorService:
		return &PlanAssignmentRequest_FieldTerminalPathValue{PlanAssignmentRequest_FieldTerminalPath: *fp, value: value.(*meta_service.Reference)}
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		return &PlanAssignmentRequest_FieldTerminalPathValue{PlanAssignmentRequest_FieldTerminalPath: *fp, value: value.(*iam_organization.Reference)}
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return &PlanAssignmentRequest_FieldTerminalPathValue{PlanAssignmentRequest_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_Status)}
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		return &PlanAssignmentRequest_FieldTerminalPathValue{PlanAssignmentRequest_FieldTerminalPath: *fp, value: value.(*ntt_meta.Meta)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequest_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequest_FieldPathSelectorName:
		return &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp, values: values.([]*Name)}
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_Request)}
	case PlanAssignmentRequest_FieldPathSelectorService:
		return &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp, values: values.([]*meta_service.Reference)}
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		return &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp, values: values.([]*iam_organization.Reference)}
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_Status)}
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		return &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp, values: values.([]*ntt_meta.Meta)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type PlanAssignmentRequest_FieldSubPath struct {
	selector PlanAssignmentRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PlanAssignmentRequest_FieldPath = (*PlanAssignmentRequest_FieldSubPath)(nil)

func (fps *PlanAssignmentRequest_FieldSubPath) Selector() PlanAssignmentRequest_FieldPathSelector {
	return fps.selector
}
func (fps *PlanAssignmentRequest_FieldSubPath) AsRequestSubPath() (PlanAssignmentRequestRequest_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestRequest_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequest_FieldSubPath) AsStatusSubPath() (PlanAssignmentRequestStatus_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestStatus_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequest_FieldSubPath) AsMetadataSubPath() (ntt_meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(ntt_meta.Meta_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source PlanAssignmentRequest
func (fps *PlanAssignmentRequest_FieldSubPath) Get(source *PlanAssignmentRequest) (values []interface{}) {
	switch fps.selector {
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		values = append(values, fps.subPath.GetRaw(source.GetRequest())...)
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		values = append(values, fps.subPath.GetRaw(source.GetStatus())...)
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetMetadata())...)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source PlanAssignmentRequest
func (fps *PlanAssignmentRequest_FieldSubPath) GetSingle(source *PlanAssignmentRequest) (interface{}, bool) {
	switch fps.selector {
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		if source.GetRequest() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetRequest())
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		if source.GetStatus() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetStatus())
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		if source.GetMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetadata())
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fps.selector))
	}
}

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

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

func (fps *PlanAssignmentRequest_FieldSubPath) ClearValue(item *PlanAssignmentRequest) {
	if item != nil {
		switch fps.selector {
		case PlanAssignmentRequest_FieldPathSelectorRequest:
			fps.subPath.ClearValueRaw(item.Request)
		case PlanAssignmentRequest_FieldPathSelectorStatus:
			fps.subPath.ClearValueRaw(item.Status)
		case PlanAssignmentRequest_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fps.selector))
		}
	}
}

func (fps *PlanAssignmentRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PlanAssignmentRequest))
}

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

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

func (fps *PlanAssignmentRequest_FieldSubPath) WithIValue(value interface{}) PlanAssignmentRequest_FieldPathValue {
	return &PlanAssignmentRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PlanAssignmentRequest_FieldSubPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequest_FieldPathArrayOfValues {
	return &PlanAssignmentRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PlanAssignmentRequest_FieldSubPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequest_FieldPathArrayItemValue {
	return &PlanAssignmentRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParsePlanAssignmentRequest_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequest_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequest_FieldTerminalPathValue struct {
	PlanAssignmentRequest_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequest_FieldPathValue = (*PlanAssignmentRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PlanAssignmentRequest' as interface{}
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) AsRequestValue() (*PlanAssignmentRequest_Request, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_Request)
	return res, ok
}
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) AsServiceValue() (*meta_service.Reference, bool) {
	res, ok := fpv.value.(*meta_service.Reference)
	return res, ok
}
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) AsApproverValue() (*iam_organization.Reference, bool) {
	res, ok := fpv.value.(*iam_organization.Reference)
	return res, ok
}
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) AsStatusValue() (*PlanAssignmentRequest_Status, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_Status)
	return res, ok
}
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) AsMetadataValue() (*ntt_meta.Meta, bool) {
	res, ok := fpv.value.(*ntt_meta.Meta)
	return res, ok
}

// SetTo stores value for selected field for object PlanAssignmentRequest
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest) {
	if *target == nil {
		*target = new(PlanAssignmentRequest)
	}
	switch fpv.selector {
	case PlanAssignmentRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		(*target).Request = fpv.value.(*PlanAssignmentRequest_Request)
	case PlanAssignmentRequest_FieldPathSelectorService:
		(*target).Service = fpv.value.(*meta_service.Reference)
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		(*target).Approver = fpv.value.(*iam_organization.Reference)
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(*PlanAssignmentRequest_Status)
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*ntt_meta.Meta)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PlanAssignmentRequest_FieldTerminalPathValue' with the value under path in 'PlanAssignmentRequest'.
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) CompareWith(source *PlanAssignmentRequest) (int, bool) {
	switch fpv.selector {
	case PlanAssignmentRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*Name)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return 0, false
	case PlanAssignmentRequest_FieldPathSelectorService:
		leftValue := fpv.value.(*meta_service.Reference)
		rightValue := source.GetService()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		leftValue := fpv.value.(*iam_organization.Reference)
		rightValue := source.GetApprover()
		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 PlanAssignmentRequest_FieldPathSelectorStatus:
		return 0, false
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fpv.selector))
	}
}

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

type PlanAssignmentRequest_FieldSubPathValue struct {
	PlanAssignmentRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PlanAssignmentRequest_FieldPathValue = (*PlanAssignmentRequest_FieldSubPathValue)(nil)

func (fpvs *PlanAssignmentRequest_FieldSubPathValue) AsRequestPathValue() (PlanAssignmentRequestRequest_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestRequest_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequest_FieldSubPathValue) AsStatusPathValue() (PlanAssignmentRequestStatus_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestStatus_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequest_FieldSubPathValue) AsMetadataPathValue() (ntt_meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ntt_meta.Meta_FieldPathValue)
	return res, ok
}

func (fpvs *PlanAssignmentRequest_FieldSubPathValue) SetTo(target **PlanAssignmentRequest) {
	if *target == nil {
		*target = new(PlanAssignmentRequest)
	}
	switch fpvs.Selector() {
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		fpvs.subPathValue.(PlanAssignmentRequestRequest_FieldPathValue).SetTo(&(*target).Request)
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		fpvs.subPathValue.(PlanAssignmentRequestStatus_FieldPathValue).SetTo(&(*target).Status)
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		fpvs.subPathValue.(ntt_meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PlanAssignmentRequest_FieldSubPathValue) CompareWith(source *PlanAssignmentRequest) (int, bool) {
	switch fpvs.Selector() {
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return fpvs.subPathValue.(PlanAssignmentRequestRequest_FieldPathValue).CompareWith(source.GetRequest())
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return fpvs.subPathValue.(PlanAssignmentRequestStatus_FieldPathValue).CompareWith(source.GetStatus())
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(ntt_meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePlanAssignmentRequest_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequest_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequest_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequest_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequest_FieldPathArrayItemValue = (*PlanAssignmentRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PlanAssignmentRequest_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *PlanAssignmentRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PlanAssignmentRequest_FieldSubPathArrayItemValue) AsRequestPathItemValue() (PlanAssignmentRequestRequest_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestRequest_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequest_FieldSubPathArrayItemValue) AsStatusPathItemValue() (PlanAssignmentRequestStatus_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestStatus_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequest_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (ntt_meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ntt_meta.Meta_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'PlanAssignmentRequest'
func (fpaivs *PlanAssignmentRequest_FieldSubPathArrayItemValue) ContainsValue(source *PlanAssignmentRequest) bool {
	switch fpaivs.Selector() {
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestRequest_FieldPathArrayItemValue).ContainsValue(source.GetRequest())
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestStatus_FieldPathArrayItemValue).ContainsValue(source.GetStatus())
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(ntt_meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest: %d", fpaivs.Selector()))
	}
}

// PlanAssignmentRequest_FieldPathArrayOfValues allows storing slice of values for PlanAssignmentRequest fields according to their type
type PlanAssignmentRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PlanAssignmentRequest_FieldPath
}

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

func MustParsePlanAssignmentRequest_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequest_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequest_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequest_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequest_FieldPathArrayOfValues = (*PlanAssignmentRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_Request) {
			values = append(values, v)
		}
	case PlanAssignmentRequest_FieldPathSelectorService:
		for _, v := range fpaov.values.([]*meta_service.Reference) {
			values = append(values, v)
		}
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		for _, v := range fpaov.values.([]*iam_organization.Reference) {
			values = append(values, v)
		}
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_Status) {
			values = append(values, v)
		}
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*ntt_meta.Meta) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsRequestArrayOfValues() ([]*PlanAssignmentRequest_Request, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_Request)
	return res, ok
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues() ([]*meta_service.Reference, bool) {
	res, ok := fpaov.values.([]*meta_service.Reference)
	return res, ok
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsApproverArrayOfValues() ([]*iam_organization.Reference, bool) {
	res, ok := fpaov.values.([]*iam_organization.Reference)
	return res, ok
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]*PlanAssignmentRequest_Status, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_Status)
	return res, ok
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*ntt_meta.Meta, bool) {
	res, ok := fpaov.values.([]*ntt_meta.Meta)
	return res, ok
}

type PlanAssignmentRequest_FieldSubPathArrayOfValues struct {
	PlanAssignmentRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PlanAssignmentRequest_FieldPathArrayOfValues = (*PlanAssignmentRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PlanAssignmentRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PlanAssignmentRequest_FieldSubPathArrayOfValues) AsRequestPathArrayOfValues() (PlanAssignmentRequestRequest_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestRequest_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequest_FieldSubPathArrayOfValues) AsStatusPathArrayOfValues() (PlanAssignmentRequestStatus_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestStatus_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequest_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (ntt_meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ntt_meta.Meta_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PlanAssignmentRequestStatus_FieldPathSelector int32

const (
	PlanAssignmentRequestStatus_FieldPathSelectorConclusion PlanAssignmentRequestStatus_FieldPathSelector = 0
	PlanAssignmentRequestStatus_FieldPathSelectorReason     PlanAssignmentRequestStatus_FieldPathSelector = 1
)

func (s PlanAssignmentRequestStatus_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestStatus_FieldPathSelectorConclusion:
		return "conclusion"
	case PlanAssignmentRequestStatus_FieldPathSelectorReason:
		return "reason"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Status: %d", s))
	}
}

func BuildPlanAssignmentRequestStatus_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestStatus_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_Status")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conclusion":
			return &PlanAssignmentRequestStatus_FieldTerminalPath{selector: PlanAssignmentRequestStatus_FieldPathSelectorConclusion}, nil
		case "reason":
			return &PlanAssignmentRequestStatus_FieldTerminalPath{selector: PlanAssignmentRequestStatus_FieldPathSelectorReason}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_Status", fp)
}

func ParsePlanAssignmentRequestStatus_FieldPath(rawField string) (PlanAssignmentRequestStatus_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestStatus_FieldPath(fp)
}

func MustParsePlanAssignmentRequestStatus_FieldPath(rawField string) PlanAssignmentRequestStatus_FieldPath {
	fp, err := ParsePlanAssignmentRequestStatus_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestStatus_FieldTerminalPath struct {
	selector PlanAssignmentRequestStatus_FieldPathSelector
}

var _ PlanAssignmentRequestStatus_FieldPath = (*PlanAssignmentRequestStatus_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestStatus_FieldTerminalPath) Selector() PlanAssignmentRequestStatus_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source PlanAssignmentRequest_Status
func (fp *PlanAssignmentRequestStatus_FieldTerminalPath) GetSingle(source *PlanAssignmentRequest_Status) (interface{}, bool) {
	switch fp.selector {
	case PlanAssignmentRequestStatus_FieldPathSelectorConclusion:
		return source.GetConclusion(), source != nil
	case PlanAssignmentRequestStatus_FieldPathSelectorReason:
		return source.GetReason(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Status: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PlanAssignmentRequestStatus_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PlanAssignmentRequestStatus_FieldPathSelectorConclusion:
		return PlanAssignmentRequest_Status_UNDEFINED
	case PlanAssignmentRequestStatus_FieldPathSelectorReason:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Status: %d", fp.selector))
	}
}

func (fp *PlanAssignmentRequestStatus_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_Status) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestStatus_FieldPathSelectorConclusion:
			item.Conclusion = PlanAssignmentRequest_Status_UNDEFINED
		case PlanAssignmentRequestStatus_FieldPathSelectorReason:
			item.Reason = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Status: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestStatus_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_Status))
}

// IsLeaf - whether field path is holds simple value
func (fp *PlanAssignmentRequestStatus_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PlanAssignmentRequestStatus_FieldPathSelectorConclusion ||
		fp.selector == PlanAssignmentRequestStatus_FieldPathSelectorReason
}

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

func (fp *PlanAssignmentRequestStatus_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestStatus_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestStatus_FieldPathSelectorConclusion:
		return &PlanAssignmentRequestStatus_FieldTerminalPathValue{PlanAssignmentRequestStatus_FieldTerminalPath: *fp, value: value.(PlanAssignmentRequest_Status_Conclusion)}
	case PlanAssignmentRequestStatus_FieldPathSelectorReason:
		return &PlanAssignmentRequestStatus_FieldTerminalPathValue{PlanAssignmentRequestStatus_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Status: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestStatus_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestStatus_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestStatus_FieldTerminalPathArrayOfValues{PlanAssignmentRequestStatus_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestStatus_FieldPathSelectorConclusion:
		return &PlanAssignmentRequestStatus_FieldTerminalPathArrayOfValues{PlanAssignmentRequestStatus_FieldTerminalPath: *fp, values: values.([]PlanAssignmentRequest_Status_Conclusion)}
	case PlanAssignmentRequestStatus_FieldPathSelectorReason:
		return &PlanAssignmentRequestStatus_FieldTerminalPathArrayOfValues{PlanAssignmentRequestStatus_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Status: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PlanAssignmentRequestStatus_FieldPathValue allows storing values for Status fields according to their type
type PlanAssignmentRequestStatus_FieldPathValue interface {
	PlanAssignmentRequestStatus_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PlanAssignmentRequest_Status)
	CompareWith(*PlanAssignmentRequest_Status) (cmp int, comparable bool)
}

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

func MustParsePlanAssignmentRequestStatus_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestStatus_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestStatus_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestStatus_FieldTerminalPathValue struct {
	PlanAssignmentRequestStatus_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestStatus_FieldPathValue = (*PlanAssignmentRequestStatus_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Status' as interface{}
func (fpv *PlanAssignmentRequestStatus_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PlanAssignmentRequestStatus_FieldTerminalPathValue) AsConclusionValue() (PlanAssignmentRequest_Status_Conclusion, bool) {
	res, ok := fpv.value.(PlanAssignmentRequest_Status_Conclusion)
	return res, ok
}
func (fpv *PlanAssignmentRequestStatus_FieldTerminalPathValue) AsReasonValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Status
func (fpv *PlanAssignmentRequestStatus_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest_Status) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_Status)
	}
	switch fpv.selector {
	case PlanAssignmentRequestStatus_FieldPathSelectorConclusion:
		(*target).Conclusion = fpv.value.(PlanAssignmentRequest_Status_Conclusion)
	case PlanAssignmentRequestStatus_FieldPathSelectorReason:
		(*target).Reason = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Status: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PlanAssignmentRequestStatus_FieldTerminalPathValue' with the value under path in 'PlanAssignmentRequest_Status'.
func (fpv *PlanAssignmentRequestStatus_FieldTerminalPathValue) CompareWith(source *PlanAssignmentRequest_Status) (int, bool) {
	switch fpv.selector {
	case PlanAssignmentRequestStatus_FieldPathSelectorConclusion:
		leftValue := fpv.value.(PlanAssignmentRequest_Status_Conclusion)
		rightValue := source.GetConclusion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PlanAssignmentRequestStatus_FieldPathSelectorReason:
		leftValue := fpv.value.(string)
		rightValue := source.GetReason()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Status: %d", fpv.selector))
	}
}

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

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

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

func MustParsePlanAssignmentRequestStatus_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestStatus_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestStatus_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestStatus_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestStatus_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestStatus_FieldPathArrayItemValue = (*PlanAssignmentRequestStatus_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PlanAssignmentRequestStatus_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_Status) (interface{}, bool) {
	return nil, false
}

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

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

// PlanAssignmentRequestStatus_FieldPathArrayOfValues allows storing slice of values for Status fields according to their type
type PlanAssignmentRequestStatus_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PlanAssignmentRequestStatus_FieldPath
}

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

func MustParsePlanAssignmentRequestStatus_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestStatus_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestStatus_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestStatus_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestStatus_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestStatus_FieldPathArrayOfValues = (*PlanAssignmentRequestStatus_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequestStatus_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequestStatus_FieldPathSelectorConclusion:
		for _, v := range fpaov.values.([]PlanAssignmentRequest_Status_Conclusion) {
			values = append(values, v)
		}
	case PlanAssignmentRequestStatus_FieldPathSelectorReason:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequestStatus_FieldTerminalPathArrayOfValues) AsConclusionArrayOfValues() ([]PlanAssignmentRequest_Status_Conclusion, bool) {
	res, ok := fpaov.values.([]PlanAssignmentRequest_Status_Conclusion)
	return res, ok
}
func (fpaov *PlanAssignmentRequestStatus_FieldTerminalPathArrayOfValues) AsReasonArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type PlanAssignmentRequestRequest_FieldPathSelector int32

const (
	PlanAssignmentRequestRequest_FieldPathSelectorAssign       PlanAssignmentRequestRequest_FieldPathSelector = 0
	PlanAssignmentRequestRequest_FieldPathSelectorExtend       PlanAssignmentRequestRequest_FieldPathSelector = 1
	PlanAssignmentRequestRequest_FieldPathSelectorRedistribute PlanAssignmentRequestRequest_FieldPathSelector = 2
	PlanAssignmentRequestRequest_FieldPathSelectorUnassign     PlanAssignmentRequestRequest_FieldPathSelector = 3
)

func (s PlanAssignmentRequestRequest_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		return "assign"
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		return "extend"
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		return "redistribute"
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		return "unassign"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", s))
	}
}

func BuildPlanAssignmentRequestRequest_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_Request")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "assign":
			return &PlanAssignmentRequestRequest_FieldTerminalPath{selector: PlanAssignmentRequestRequest_FieldPathSelectorAssign}, nil
		case "extend":
			return &PlanAssignmentRequestRequest_FieldTerminalPath{selector: PlanAssignmentRequestRequest_FieldPathSelectorExtend}, nil
		case "redistribute":
			return &PlanAssignmentRequestRequest_FieldTerminalPath{selector: PlanAssignmentRequestRequest_FieldPathSelectorRedistribute}, nil
		case "unassign":
			return &PlanAssignmentRequestRequest_FieldTerminalPath{selector: PlanAssignmentRequestRequest_FieldPathSelectorUnassign}, nil
		}
	} else {
		switch fp[0] {
		case "assign":
			if subpath, err := BuildPlanAssignmentRequestRequestAssign_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequest_FieldSubPath{selector: PlanAssignmentRequestRequest_FieldPathSelectorAssign, subPath: subpath}, nil
			}
		case "extend":
			if subpath, err := BuildPlanAssignmentRequestRequestExtend_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequest_FieldSubPath{selector: PlanAssignmentRequestRequest_FieldPathSelectorExtend, subPath: subpath}, nil
			}
		case "redistribute":
			if subpath, err := BuildPlanAssignmentRequestRequestRedistribute_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequest_FieldSubPath{selector: PlanAssignmentRequestRequest_FieldPathSelectorRedistribute, subPath: subpath}, nil
			}
		case "unassign":
			if subpath, err := BuildPlanAssignmentRequestRequestUnassign_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequest_FieldSubPath{selector: PlanAssignmentRequestRequest_FieldPathSelectorUnassign, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_Request", fp)
}

func ParsePlanAssignmentRequestRequest_FieldPath(rawField string) (PlanAssignmentRequestRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestRequest_FieldPath(fp)
}

func MustParsePlanAssignmentRequestRequest_FieldPath(rawField string) PlanAssignmentRequestRequest_FieldPath {
	fp, err := ParsePlanAssignmentRequestRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestRequest_FieldTerminalPath struct {
	selector PlanAssignmentRequestRequest_FieldPathSelector
}

var _ PlanAssignmentRequestRequest_FieldPath = (*PlanAssignmentRequestRequest_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestRequest_FieldTerminalPath) Selector() PlanAssignmentRequestRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PlanAssignmentRequest_Request
func (fp *PlanAssignmentRequestRequest_FieldTerminalPath) Get(source *PlanAssignmentRequest_Request) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
			if source, ok := source.Request.(*PlanAssignmentRequest_Request_Assign_); ok && source != nil {
				if source.Assign != nil {
					values = append(values, source.Assign)
				}
			}
		case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
			if source, ok := source.Request.(*PlanAssignmentRequest_Request_Extend_); ok && source != nil {
				if source.Extend != nil {
					values = append(values, source.Extend)
				}
			}
		case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
			if source, ok := source.Request.(*PlanAssignmentRequest_Request_Redistribute_); ok && source != nil {
				if source.Redistribute != nil {
					values = append(values, source.Redistribute)
				}
			}
		case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
			if source, ok := source.Request.(*PlanAssignmentRequest_Request_Unassign_); ok && source != nil {
				if source.Unassign != nil {
					values = append(values, source.Unassign)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PlanAssignmentRequest_Request
func (fp *PlanAssignmentRequestRequest_FieldTerminalPath) GetSingle(source *PlanAssignmentRequest_Request) (interface{}, bool) {
	switch fp.selector {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		res := source.GetAssign()
		return res, res != nil
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		res := source.GetExtend()
		return res, res != nil
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		res := source.GetRedistribute()
		return res, res != nil
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		res := source.GetUnassign()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PlanAssignmentRequestRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		return (*PlanAssignmentRequest_Request_Assign)(nil)
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		return (*PlanAssignmentRequest_Request_Extend)(nil)
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		return (*PlanAssignmentRequest_Request_Redistribute)(nil)
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		return (*PlanAssignmentRequest_Request_Unassign)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fp.selector))
	}
}

func (fp *PlanAssignmentRequestRequest_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_Request) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
			if item, ok := item.Request.(*PlanAssignmentRequest_Request_Assign_); ok {
				item.Assign = nil
			}
		case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
			if item, ok := item.Request.(*PlanAssignmentRequest_Request_Extend_); ok {
				item.Extend = nil
			}
		case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
			if item, ok := item.Request.(*PlanAssignmentRequest_Request_Redistribute_); ok {
				item.Redistribute = nil
			}
		case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
			if item, ok := item.Request.(*PlanAssignmentRequest_Request_Unassign_); ok {
				item.Unassign = nil
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_Request))
}

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

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

func (fp *PlanAssignmentRequestRequest_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestRequest_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		return &PlanAssignmentRequestRequest_FieldTerminalPathValue{PlanAssignmentRequestRequest_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_Request_Assign)}
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		return &PlanAssignmentRequestRequest_FieldTerminalPathValue{PlanAssignmentRequestRequest_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_Request_Extend)}
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		return &PlanAssignmentRequestRequest_FieldTerminalPathValue{PlanAssignmentRequestRequest_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_Request_Redistribute)}
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		return &PlanAssignmentRequestRequest_FieldTerminalPathValue{PlanAssignmentRequestRequest_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_Request_Unassign)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequest_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		return &PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequest_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_Request_Assign)}
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		return &PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequest_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_Request_Extend)}
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		return &PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequest_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_Request_Redistribute)}
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		return &PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequest_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_Request_Unassign)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type PlanAssignmentRequestRequest_FieldSubPath struct {
	selector PlanAssignmentRequestRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PlanAssignmentRequestRequest_FieldPath = (*PlanAssignmentRequestRequest_FieldSubPath)(nil)

func (fps *PlanAssignmentRequestRequest_FieldSubPath) Selector() PlanAssignmentRequestRequest_FieldPathSelector {
	return fps.selector
}
func (fps *PlanAssignmentRequestRequest_FieldSubPath) AsAssignSubPath() (PlanAssignmentRequestRequestAssign_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestRequestAssign_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequestRequest_FieldSubPath) AsExtendSubPath() (PlanAssignmentRequestRequestExtend_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestRequestExtend_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequestRequest_FieldSubPath) AsRedistributeSubPath() (PlanAssignmentRequestRequestRedistribute_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestRequestRedistribute_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequestRequest_FieldSubPath) AsUnassignSubPath() (PlanAssignmentRequestRequestUnassign_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestRequestUnassign_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source PlanAssignmentRequest_Request
func (fps *PlanAssignmentRequestRequest_FieldSubPath) Get(source *PlanAssignmentRequest_Request) (values []interface{}) {
	switch fps.selector {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		values = append(values, fps.subPath.GetRaw(source.GetAssign())...)
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		values = append(values, fps.subPath.GetRaw(source.GetExtend())...)
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		values = append(values, fps.subPath.GetRaw(source.GetRedistribute())...)
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		values = append(values, fps.subPath.GetRaw(source.GetUnassign())...)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source PlanAssignmentRequest_Request
func (fps *PlanAssignmentRequestRequest_FieldSubPath) GetSingle(source *PlanAssignmentRequest_Request) (interface{}, bool) {
	switch fps.selector {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		if source.GetAssign() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAssign())
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		if source.GetExtend() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetExtend())
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		if source.GetRedistribute() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetRedistribute())
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		if source.GetUnassign() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetUnassign())
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fps.selector))
	}
}

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

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

func (fps *PlanAssignmentRequestRequest_FieldSubPath) ClearValue(item *PlanAssignmentRequest_Request) {
	if item != nil {
		switch fps.selector {
		case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
			if item.Request != nil {
				if item, ok := item.Request.(*PlanAssignmentRequest_Request_Assign_); ok {
					fps.subPath.ClearValueRaw(item.Assign)
				}
			}
		case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
			if item.Request != nil {
				if item, ok := item.Request.(*PlanAssignmentRequest_Request_Extend_); ok {
					fps.subPath.ClearValueRaw(item.Extend)
				}
			}
		case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
			if item.Request != nil {
				if item, ok := item.Request.(*PlanAssignmentRequest_Request_Redistribute_); ok {
					fps.subPath.ClearValueRaw(item.Redistribute)
				}
			}
		case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
			if item.Request != nil {
				if item, ok := item.Request.(*PlanAssignmentRequest_Request_Unassign_); ok {
					fps.subPath.ClearValueRaw(item.Unassign)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fps.selector))
		}
	}
}

func (fps *PlanAssignmentRequestRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PlanAssignmentRequest_Request))
}

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

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

func (fps *PlanAssignmentRequestRequest_FieldSubPath) WithIValue(value interface{}) PlanAssignmentRequestRequest_FieldPathValue {
	return &PlanAssignmentRequestRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PlanAssignmentRequestRequest_FieldSubPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequest_FieldPathArrayOfValues {
	return &PlanAssignmentRequestRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PlanAssignmentRequestRequest_FieldSubPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequest_FieldPathArrayItemValue {
	return &PlanAssignmentRequestRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PlanAssignmentRequestRequest_FieldPathValue allows storing values for Request fields according to their type
type PlanAssignmentRequestRequest_FieldPathValue interface {
	PlanAssignmentRequestRequest_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PlanAssignmentRequest_Request)
	CompareWith(*PlanAssignmentRequest_Request) (cmp int, comparable bool)
}

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

func MustParsePlanAssignmentRequestRequest_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestRequest_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestRequest_FieldTerminalPathValue struct {
	PlanAssignmentRequestRequest_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequest_FieldPathValue = (*PlanAssignmentRequestRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Request' as interface{}
func (fpv *PlanAssignmentRequestRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PlanAssignmentRequestRequest_FieldTerminalPathValue) AsAssignValue() (*PlanAssignmentRequest_Request_Assign, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_Request_Assign)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequest_FieldTerminalPathValue) AsExtendValue() (*PlanAssignmentRequest_Request_Extend, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_Request_Extend)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequest_FieldTerminalPathValue) AsRedistributeValue() (*PlanAssignmentRequest_Request_Redistribute, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_Request_Redistribute)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequest_FieldTerminalPathValue) AsUnassignValue() (*PlanAssignmentRequest_Request_Unassign, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_Request_Unassign)
	return res, ok
}

// SetTo stores value for selected field for object Request
func (fpv *PlanAssignmentRequestRequest_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest_Request) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_Request)
	}
	switch fpv.selector {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_Request_Assign_); !ok {
			(*target).Request = &PlanAssignmentRequest_Request_Assign_{}
		}
		(*target).Request.(*PlanAssignmentRequest_Request_Assign_).Assign = fpv.value.(*PlanAssignmentRequest_Request_Assign)
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_Request_Extend_); !ok {
			(*target).Request = &PlanAssignmentRequest_Request_Extend_{}
		}
		(*target).Request.(*PlanAssignmentRequest_Request_Extend_).Extend = fpv.value.(*PlanAssignmentRequest_Request_Extend)
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_Request_Redistribute_); !ok {
			(*target).Request = &PlanAssignmentRequest_Request_Redistribute_{}
		}
		(*target).Request.(*PlanAssignmentRequest_Request_Redistribute_).Redistribute = fpv.value.(*PlanAssignmentRequest_Request_Redistribute)
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_Request_Unassign_); !ok {
			(*target).Request = &PlanAssignmentRequest_Request_Unassign_{}
		}
		(*target).Request.(*PlanAssignmentRequest_Request_Unassign_).Unassign = fpv.value.(*PlanAssignmentRequest_Request_Unassign)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fpv.selector))
	}
}

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

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

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

type PlanAssignmentRequestRequest_FieldSubPathValue struct {
	PlanAssignmentRequestRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PlanAssignmentRequestRequest_FieldPathValue = (*PlanAssignmentRequestRequest_FieldSubPathValue)(nil)

func (fpvs *PlanAssignmentRequestRequest_FieldSubPathValue) AsAssignPathValue() (PlanAssignmentRequestRequestAssign_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestRequestAssign_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequestRequest_FieldSubPathValue) AsExtendPathValue() (PlanAssignmentRequestRequestExtend_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestRequestExtend_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequestRequest_FieldSubPathValue) AsRedistributePathValue() (PlanAssignmentRequestRequestRedistribute_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestRequestRedistribute_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequestRequest_FieldSubPathValue) AsUnassignPathValue() (PlanAssignmentRequestRequestUnassign_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestRequestUnassign_FieldPathValue)
	return res, ok
}

func (fpvs *PlanAssignmentRequestRequest_FieldSubPathValue) SetTo(target **PlanAssignmentRequest_Request) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_Request)
	}
	switch fpvs.Selector() {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_Request_Assign_); !ok {
			(*target).Request = &PlanAssignmentRequest_Request_Assign_{}
		}
		fpvs.subPathValue.(PlanAssignmentRequestRequestAssign_FieldPathValue).SetTo(&(*target).Request.(*PlanAssignmentRequest_Request_Assign_).Assign)
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_Request_Extend_); !ok {
			(*target).Request = &PlanAssignmentRequest_Request_Extend_{}
		}
		fpvs.subPathValue.(PlanAssignmentRequestRequestExtend_FieldPathValue).SetTo(&(*target).Request.(*PlanAssignmentRequest_Request_Extend_).Extend)
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_Request_Redistribute_); !ok {
			(*target).Request = &PlanAssignmentRequest_Request_Redistribute_{}
		}
		fpvs.subPathValue.(PlanAssignmentRequestRequestRedistribute_FieldPathValue).SetTo(&(*target).Request.(*PlanAssignmentRequest_Request_Redistribute_).Redistribute)
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_Request_Unassign_); !ok {
			(*target).Request = &PlanAssignmentRequest_Request_Unassign_{}
		}
		fpvs.subPathValue.(PlanAssignmentRequestRequestUnassign_FieldPathValue).SetTo(&(*target).Request.(*PlanAssignmentRequest_Request_Unassign_).Unassign)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PlanAssignmentRequestRequest_FieldSubPathValue) CompareWith(source *PlanAssignmentRequest_Request) (int, bool) {
	switch fpvs.Selector() {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		return fpvs.subPathValue.(PlanAssignmentRequestRequestAssign_FieldPathValue).CompareWith(source.GetAssign())
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		return fpvs.subPathValue.(PlanAssignmentRequestRequestExtend_FieldPathValue).CompareWith(source.GetExtend())
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		return fpvs.subPathValue.(PlanAssignmentRequestRequestRedistribute_FieldPathValue).CompareWith(source.GetRedistribute())
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		return fpvs.subPathValue.(PlanAssignmentRequestRequestUnassign_FieldPathValue).CompareWith(source.GetUnassign())
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePlanAssignmentRequestRequest_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestRequest_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestRequest_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestRequest_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequest_FieldPathArrayItemValue = (*PlanAssignmentRequestRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PlanAssignmentRequestRequest_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_Request) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Request'
func (fpaiv *PlanAssignmentRequestRequest_FieldTerminalPathArrayItemValue) ContainsValue(source *PlanAssignmentRequest_Request) bool {
	slice := fpaiv.PlanAssignmentRequestRequest_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 PlanAssignmentRequestRequest_FieldSubPathArrayItemValue struct {
	PlanAssignmentRequestRequest_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PlanAssignmentRequestRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PlanAssignmentRequestRequest_FieldSubPathArrayItemValue) AsAssignPathItemValue() (PlanAssignmentRequestRequestAssign_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestRequestAssign_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequestRequest_FieldSubPathArrayItemValue) AsExtendPathItemValue() (PlanAssignmentRequestRequestExtend_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestRequestExtend_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequestRequest_FieldSubPathArrayItemValue) AsRedistributePathItemValue() (PlanAssignmentRequestRequestRedistribute_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestRequestRedistribute_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequestRequest_FieldSubPathArrayItemValue) AsUnassignPathItemValue() (PlanAssignmentRequestRequestUnassign_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestRequestUnassign_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Request'
func (fpaivs *PlanAssignmentRequestRequest_FieldSubPathArrayItemValue) ContainsValue(source *PlanAssignmentRequest_Request) bool {
	switch fpaivs.Selector() {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestRequestAssign_FieldPathArrayItemValue).ContainsValue(source.GetAssign())
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestRequestExtend_FieldPathArrayItemValue).ContainsValue(source.GetExtend())
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestRequestRedistribute_FieldPathArrayItemValue).ContainsValue(source.GetRedistribute())
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestRequestUnassign_FieldPathArrayItemValue).ContainsValue(source.GetUnassign())
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request: %d", fpaivs.Selector()))
	}
}

// PlanAssignmentRequestRequest_FieldPathArrayOfValues allows storing slice of values for Request fields according to their type
type PlanAssignmentRequestRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PlanAssignmentRequestRequest_FieldPath
}

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

func MustParsePlanAssignmentRequestRequest_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestRequest_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestRequest_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestRequest_FieldPathArrayOfValues = (*PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequestRequest_FieldPathSelectorAssign:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_Request_Assign) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequest_FieldPathSelectorExtend:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_Request_Extend) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequest_FieldPathSelectorRedistribute:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_Request_Redistribute) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequest_FieldPathSelectorUnassign:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_Request_Unassign) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues) AsAssignArrayOfValues() ([]*PlanAssignmentRequest_Request_Assign, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_Request_Assign)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues) AsExtendArrayOfValues() ([]*PlanAssignmentRequest_Request_Extend, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_Request_Extend)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues) AsRedistributeArrayOfValues() ([]*PlanAssignmentRequest_Request_Redistribute, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_Request_Redistribute)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequest_FieldTerminalPathArrayOfValues) AsUnassignArrayOfValues() ([]*PlanAssignmentRequest_Request_Unassign, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_Request_Unassign)
	return res, ok
}

type PlanAssignmentRequestRequest_FieldSubPathArrayOfValues struct {
	PlanAssignmentRequestRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PlanAssignmentRequestRequest_FieldPathArrayOfValues = (*PlanAssignmentRequestRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PlanAssignmentRequestRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PlanAssignmentRequestRequest_FieldSubPathArrayOfValues) AsAssignPathArrayOfValues() (PlanAssignmentRequestRequestAssign_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestRequestAssign_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequestRequest_FieldSubPathArrayOfValues) AsExtendPathArrayOfValues() (PlanAssignmentRequestRequestExtend_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestRequestExtend_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequestRequest_FieldSubPathArrayOfValues) AsRedistributePathArrayOfValues() (PlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequestRequest_FieldSubPathArrayOfValues) AsUnassignPathArrayOfValues() (PlanAssignmentRequestRequestUnassign_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestRequestUnassign_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PlanAssignmentRequestRequestAssign_FieldPathSelector int32

const (
	PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan                  PlanAssignmentRequestRequestAssign_FieldPathSelector = 0
	PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions            PlanAssignmentRequestRequestAssign_FieldPathSelector = 1
	PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions PlanAssignmentRequestRequestAssign_FieldPathSelector = 2
)

func (s PlanAssignmentRequestRequestAssign_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
		return "plan"
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
		return "extensions"
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
		return "regional_distributions"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", s))
	}
}

func BuildPlanAssignmentRequestRequestAssign_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestRequestAssign_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_Request_Assign")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "plan":
			return &PlanAssignmentRequestRequestAssign_FieldTerminalPath{selector: PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan}, nil
		case "extensions":
			return &PlanAssignmentRequestRequestAssign_FieldTerminalPath{selector: PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions}, nil
		case "regional_distributions", "regionalDistributions", "regional-distributions":
			return &PlanAssignmentRequestRequestAssign_FieldTerminalPath{selector: PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions}, nil
		}
	} else {
		switch fp[0] {
		case "extensions":
			if subpath, err := common.BuildAllowance_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestAssign_FieldSubPath{selector: PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions, subPath: subpath}, nil
			}
		case "regional_distributions", "regionalDistributions", "regional-distributions":
			if subpath, err := common.BuildRegionalDistribution_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestAssign_FieldSubPath{selector: PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_Request_Assign", fp)
}

func ParsePlanAssignmentRequestRequestAssign_FieldPath(rawField string) (PlanAssignmentRequestRequestAssign_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestRequestAssign_FieldPath(fp)
}

func MustParsePlanAssignmentRequestRequestAssign_FieldPath(rawField string) PlanAssignmentRequestRequestAssign_FieldPath {
	fp, err := ParsePlanAssignmentRequestRequestAssign_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestRequestAssign_FieldTerminalPath struct {
	selector PlanAssignmentRequestRequestAssign_FieldPathSelector
}

var _ PlanAssignmentRequestRequestAssign_FieldPath = (*PlanAssignmentRequestRequestAssign_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestRequestAssign_FieldTerminalPath) Selector() PlanAssignmentRequestRequestAssign_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PlanAssignmentRequest_Request_Assign
func (fp *PlanAssignmentRequestRequestAssign_FieldTerminalPath) Get(source *PlanAssignmentRequest_Request_Assign) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
			if source.Plan != nil {
				values = append(values, source.Plan)
			}
		case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
			for _, value := range source.GetExtensions() {
				values = append(values, value)
			}
		case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
			for _, value := range source.GetRegionalDistributions() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PlanAssignmentRequest_Request_Assign
func (fp *PlanAssignmentRequestRequestAssign_FieldTerminalPath) GetSingle(source *PlanAssignmentRequest_Request_Assign) (interface{}, bool) {
	switch fp.selector {
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
		res := source.GetPlan()
		return res, res != nil
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
		res := source.GetExtensions()
		return res, res != nil
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
		res := source.GetRegionalDistributions()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PlanAssignmentRequestRequestAssign_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
		return (*plan.Reference)(nil)
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
		return ([]*common.Allowance)(nil)
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
		return ([]*common.RegionalDistribution)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fp.selector))
	}
}

func (fp *PlanAssignmentRequestRequestAssign_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_Request_Assign) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
			item.Plan = nil
		case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
			item.Extensions = nil
		case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
			item.RegionalDistributions = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestRequestAssign_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_Request_Assign))
}

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

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

func (fp *PlanAssignmentRequestRequestAssign_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestRequestAssign_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
		return &PlanAssignmentRequestRequestAssign_FieldTerminalPathValue{PlanAssignmentRequestRequestAssign_FieldTerminalPath: *fp, value: value.(*plan.Reference)}
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
		return &PlanAssignmentRequestRequestAssign_FieldTerminalPathValue{PlanAssignmentRequestRequestAssign_FieldTerminalPath: *fp, value: value.([]*common.Allowance)}
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
		return &PlanAssignmentRequestRequestAssign_FieldTerminalPathValue{PlanAssignmentRequestRequestAssign_FieldTerminalPath: *fp, value: value.([]*common.RegionalDistribution)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestRequestAssign_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestAssign_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestAssign_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
		return &PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestAssign_FieldTerminalPath: *fp, values: values.([]*plan.Reference)}
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
		return &PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestAssign_FieldTerminalPath: *fp, values: values.([][]*common.Allowance)}
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
		return &PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestAssign_FieldTerminalPath: *fp, values: values.([][]*common.RegionalDistribution)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PlanAssignmentRequestRequestAssign_FieldTerminalPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestAssign_FieldPathArrayItemValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
		return &PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayItemValue{PlanAssignmentRequestRequestAssign_FieldTerminalPath: *fp, value: value.(*common.Allowance)}
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
		return &PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayItemValue{PlanAssignmentRequestRequestAssign_FieldTerminalPath: *fp, value: value.(*common.RegionalDistribution)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fp.selector))
	}
}

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

type PlanAssignmentRequestRequestAssign_FieldSubPath struct {
	selector PlanAssignmentRequestRequestAssign_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PlanAssignmentRequestRequestAssign_FieldPath = (*PlanAssignmentRequestRequestAssign_FieldSubPath)(nil)

func (fps *PlanAssignmentRequestRequestAssign_FieldSubPath) Selector() PlanAssignmentRequestRequestAssign_FieldPathSelector {
	return fps.selector
}
func (fps *PlanAssignmentRequestRequestAssign_FieldSubPath) AsExtensionsSubPath() (common.Allowance_FieldPath, bool) {
	res, ok := fps.subPath.(common.Allowance_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequestRequestAssign_FieldSubPath) AsRegionalDistributionsSubPath() (common.RegionalDistribution_FieldPath, bool) {
	res, ok := fps.subPath.(common.RegionalDistribution_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *PlanAssignmentRequestRequestAssign_FieldSubPath) ClearValue(item *PlanAssignmentRequest_Request_Assign) {
	if item != nil {
		switch fps.selector {
		case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
			for _, subItem := range item.Extensions {
				fps.subPath.ClearValueRaw(subItem)
			}
		case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
			for _, subItem := range item.RegionalDistributions {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fps.selector))
		}
	}
}

func (fps *PlanAssignmentRequestRequestAssign_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PlanAssignmentRequest_Request_Assign))
}

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

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

func (fps *PlanAssignmentRequestRequestAssign_FieldSubPath) WithIValue(value interface{}) PlanAssignmentRequestRequestAssign_FieldPathValue {
	return &PlanAssignmentRequestRequestAssign_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PlanAssignmentRequestRequestAssign_FieldSubPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestAssign_FieldPathArrayOfValues {
	return &PlanAssignmentRequestRequestAssign_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PlanAssignmentRequestRequestAssign_FieldSubPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestAssign_FieldPathArrayItemValue {
	return &PlanAssignmentRequestRequestAssign_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PlanAssignmentRequestRequestAssign_FieldPathValue allows storing values for Assign fields according to their type
type PlanAssignmentRequestRequestAssign_FieldPathValue interface {
	PlanAssignmentRequestRequestAssign_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PlanAssignmentRequest_Request_Assign)
	CompareWith(*PlanAssignmentRequest_Request_Assign) (cmp int, comparable bool)
}

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

func MustParsePlanAssignmentRequestRequestAssign_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestRequestAssign_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestRequestAssign_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestRequestAssign_FieldTerminalPathValue struct {
	PlanAssignmentRequestRequestAssign_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestAssign_FieldPathValue = (*PlanAssignmentRequestRequestAssign_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Assign' as interface{}
func (fpv *PlanAssignmentRequestRequestAssign_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PlanAssignmentRequestRequestAssign_FieldTerminalPathValue) AsPlanValue() (*plan.Reference, bool) {
	res, ok := fpv.value.(*plan.Reference)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequestAssign_FieldTerminalPathValue) AsExtensionsValue() ([]*common.Allowance, bool) {
	res, ok := fpv.value.([]*common.Allowance)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequestAssign_FieldTerminalPathValue) AsRegionalDistributionsValue() ([]*common.RegionalDistribution, bool) {
	res, ok := fpv.value.([]*common.RegionalDistribution)
	return res, ok
}

// SetTo stores value for selected field for object Assign
func (fpv *PlanAssignmentRequestRequestAssign_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest_Request_Assign) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_Request_Assign)
	}
	switch fpv.selector {
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
		(*target).Plan = fpv.value.(*plan.Reference)
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
		(*target).Extensions = fpv.value.([]*common.Allowance)
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
		(*target).RegionalDistributions = fpv.value.([]*common.RegionalDistribution)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PlanAssignmentRequestRequestAssign_FieldTerminalPathValue' with the value under path in 'PlanAssignmentRequest_Request_Assign'.
func (fpv *PlanAssignmentRequestRequestAssign_FieldTerminalPathValue) CompareWith(source *PlanAssignmentRequest_Request_Assign) (int, bool) {
	switch fpv.selector {
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
		leftValue := fpv.value.(*plan.Reference)
		rightValue := source.GetPlan()
		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 PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
		return 0, false
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Assign: %d", fpv.selector))
	}
}

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

type PlanAssignmentRequestRequestAssign_FieldSubPathValue struct {
	PlanAssignmentRequestRequestAssign_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PlanAssignmentRequestRequestAssign_FieldPathValue = (*PlanAssignmentRequestRequestAssign_FieldSubPathValue)(nil)

func (fpvs *PlanAssignmentRequestRequestAssign_FieldSubPathValue) AsExtensionsPathValue() (common.Allowance_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.Allowance_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequestRequestAssign_FieldSubPathValue) AsRegionalDistributionsPathValue() (common.RegionalDistribution_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.RegionalDistribution_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParsePlanAssignmentRequestRequestAssign_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestRequestAssign_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestRequestAssign_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestRequestAssign_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestAssign_FieldPathArrayItemValue = (*PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object PlanAssignmentRequest_Request_Assign as interface{}
func (fpaiv *PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayItemValue) AsExtensionsItemValue() (*common.Allowance, bool) {
	res, ok := fpaiv.value.(*common.Allowance)
	return res, ok
}
func (fpaiv *PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayItemValue) AsRegionalDistributionsItemValue() (*common.RegionalDistribution, bool) {
	res, ok := fpaiv.value.(*common.RegionalDistribution)
	return res, ok
}

func (fpaiv *PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_Request_Assign) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Assign'
func (fpaiv *PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayItemValue) ContainsValue(source *PlanAssignmentRequest_Request_Assign) bool {
	slice := fpaiv.PlanAssignmentRequestRequestAssign_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 PlanAssignmentRequestRequestAssign_FieldSubPathArrayItemValue struct {
	PlanAssignmentRequestRequestAssign_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PlanAssignmentRequestRequestAssign_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PlanAssignmentRequestRequestAssign_FieldSubPathArrayItemValue) AsExtensionsPathItemValue() (common.Allowance_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.Allowance_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequestRequestAssign_FieldSubPathArrayItemValue) AsRegionalDistributionsPathItemValue() (common.RegionalDistribution_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.RegionalDistribution_FieldPathArrayItemValue)
	return res, ok
}

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

// PlanAssignmentRequestRequestAssign_FieldPathArrayOfValues allows storing slice of values for Assign fields according to their type
type PlanAssignmentRequestRequestAssign_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PlanAssignmentRequestRequestAssign_FieldPath
}

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

func MustParsePlanAssignmentRequestRequestAssign_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestRequestAssign_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestRequestAssign_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestRequestAssign_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestRequestAssign_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorPlan:
		for _, v := range fpaov.values.([]*plan.Reference) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorExtensions:
		for _, v := range fpaov.values.([][]*common.Allowance) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestAssign_FieldPathSelectorRegionalDistributions:
		for _, v := range fpaov.values.([][]*common.RegionalDistribution) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues) AsPlanArrayOfValues() ([]*plan.Reference, bool) {
	res, ok := fpaov.values.([]*plan.Reference)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues) AsExtensionsArrayOfValues() ([][]*common.Allowance, bool) {
	res, ok := fpaov.values.([][]*common.Allowance)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestAssign_FieldTerminalPathArrayOfValues) AsRegionalDistributionsArrayOfValues() ([][]*common.RegionalDistribution, bool) {
	res, ok := fpaov.values.([][]*common.RegionalDistribution)
	return res, ok
}

type PlanAssignmentRequestRequestAssign_FieldSubPathArrayOfValues struct {
	PlanAssignmentRequestRequestAssign_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PlanAssignmentRequestRequestAssign_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestAssign_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PlanAssignmentRequestRequestAssign_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PlanAssignmentRequestRequestAssign_FieldSubPathArrayOfValues) AsExtensionsPathArrayOfValues() (common.Allowance_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.Allowance_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequestRequestAssign_FieldSubPathArrayOfValues) AsRegionalDistributionsPathArrayOfValues() (common.RegionalDistribution_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.RegionalDistribution_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PlanAssignmentRequestRequestExtend_FieldPathSelector int32

const (
	PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment            PlanAssignmentRequestRequestExtend_FieldPathSelector = 0
	PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions             PlanAssignmentRequestRequestExtend_FieldPathSelector = 1
	PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions PlanAssignmentRequestRequestExtend_FieldPathSelector = 2
)

func (s PlanAssignmentRequestRequestExtend_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
		return "assignment"
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
		return "additions"
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
		return "regional_distributions"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", s))
	}
}

func BuildPlanAssignmentRequestRequestExtend_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestRequestExtend_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_Request_Extend")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "assignment":
			return &PlanAssignmentRequestRequestExtend_FieldTerminalPath{selector: PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment}, nil
		case "additions":
			return &PlanAssignmentRequestRequestExtend_FieldTerminalPath{selector: PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions}, nil
		case "regional_distributions", "regionalDistributions", "regional-distributions":
			return &PlanAssignmentRequestRequestExtend_FieldTerminalPath{selector: PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions}, nil
		}
	} else {
		switch fp[0] {
		case "additions":
			if subpath, err := common.BuildAllowance_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestExtend_FieldSubPath{selector: PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions, subPath: subpath}, nil
			}
		case "regional_distributions", "regionalDistributions", "regional-distributions":
			if subpath, err := common.BuildRegionalDistribution_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestExtend_FieldSubPath{selector: PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_Request_Extend", fp)
}

func ParsePlanAssignmentRequestRequestExtend_FieldPath(rawField string) (PlanAssignmentRequestRequestExtend_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestRequestExtend_FieldPath(fp)
}

func MustParsePlanAssignmentRequestRequestExtend_FieldPath(rawField string) PlanAssignmentRequestRequestExtend_FieldPath {
	fp, err := ParsePlanAssignmentRequestRequestExtend_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestRequestExtend_FieldTerminalPath struct {
	selector PlanAssignmentRequestRequestExtend_FieldPathSelector
}

var _ PlanAssignmentRequestRequestExtend_FieldPath = (*PlanAssignmentRequestRequestExtend_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestRequestExtend_FieldTerminalPath) Selector() PlanAssignmentRequestRequestExtend_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PlanAssignmentRequest_Request_Extend
func (fp *PlanAssignmentRequestRequestExtend_FieldTerminalPath) Get(source *PlanAssignmentRequest_Request_Extend) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
			if source.Assignment != nil {
				values = append(values, source.Assignment)
			}
		case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
			for _, value := range source.GetAdditions() {
				values = append(values, value)
			}
		case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
			for _, value := range source.GetRegionalDistributions() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PlanAssignmentRequest_Request_Extend
func (fp *PlanAssignmentRequestRequestExtend_FieldTerminalPath) GetSingle(source *PlanAssignmentRequest_Request_Extend) (interface{}, bool) {
	switch fp.selector {
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
		res := source.GetAssignment()
		return res, res != nil
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
		res := source.GetAdditions()
		return res, res != nil
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
		res := source.GetRegionalDistributions()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PlanAssignmentRequestRequestExtend_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
		return (*plan_assignment.Reference)(nil)
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
		return ([]*common.Allowance)(nil)
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
		return ([]*common.RegionalDistribution)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fp.selector))
	}
}

func (fp *PlanAssignmentRequestRequestExtend_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_Request_Extend) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
			item.Assignment = nil
		case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
			item.Additions = nil
		case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
			item.RegionalDistributions = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestRequestExtend_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_Request_Extend))
}

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

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

func (fp *PlanAssignmentRequestRequestExtend_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestRequestExtend_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestExtend_FieldTerminalPathValue{PlanAssignmentRequestRequestExtend_FieldTerminalPath: *fp, value: value.(*plan_assignment.Reference)}
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
		return &PlanAssignmentRequestRequestExtend_FieldTerminalPathValue{PlanAssignmentRequestRequestExtend_FieldTerminalPath: *fp, value: value.([]*common.Allowance)}
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
		return &PlanAssignmentRequestRequestExtend_FieldTerminalPathValue{PlanAssignmentRequestRequestExtend_FieldTerminalPath: *fp, value: value.([]*common.RegionalDistribution)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestRequestExtend_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestExtend_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestExtend_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestExtend_FieldTerminalPath: *fp, values: values.([]*plan_assignment.Reference)}
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
		return &PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestExtend_FieldTerminalPath: *fp, values: values.([][]*common.Allowance)}
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
		return &PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestExtend_FieldTerminalPath: *fp, values: values.([][]*common.RegionalDistribution)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PlanAssignmentRequestRequestExtend_FieldTerminalPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestExtend_FieldPathArrayItemValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
		return &PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayItemValue{PlanAssignmentRequestRequestExtend_FieldTerminalPath: *fp, value: value.(*common.Allowance)}
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
		return &PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayItemValue{PlanAssignmentRequestRequestExtend_FieldTerminalPath: *fp, value: value.(*common.RegionalDistribution)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fp.selector))
	}
}

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

type PlanAssignmentRequestRequestExtend_FieldSubPath struct {
	selector PlanAssignmentRequestRequestExtend_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PlanAssignmentRequestRequestExtend_FieldPath = (*PlanAssignmentRequestRequestExtend_FieldSubPath)(nil)

func (fps *PlanAssignmentRequestRequestExtend_FieldSubPath) Selector() PlanAssignmentRequestRequestExtend_FieldPathSelector {
	return fps.selector
}
func (fps *PlanAssignmentRequestRequestExtend_FieldSubPath) AsAdditionsSubPath() (common.Allowance_FieldPath, bool) {
	res, ok := fps.subPath.(common.Allowance_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequestRequestExtend_FieldSubPath) AsRegionalDistributionsSubPath() (common.RegionalDistribution_FieldPath, bool) {
	res, ok := fps.subPath.(common.RegionalDistribution_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *PlanAssignmentRequestRequestExtend_FieldSubPath) ClearValue(item *PlanAssignmentRequest_Request_Extend) {
	if item != nil {
		switch fps.selector {
		case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
			for _, subItem := range item.Additions {
				fps.subPath.ClearValueRaw(subItem)
			}
		case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
			for _, subItem := range item.RegionalDistributions {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fps.selector))
		}
	}
}

func (fps *PlanAssignmentRequestRequestExtend_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PlanAssignmentRequest_Request_Extend))
}

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

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

func (fps *PlanAssignmentRequestRequestExtend_FieldSubPath) WithIValue(value interface{}) PlanAssignmentRequestRequestExtend_FieldPathValue {
	return &PlanAssignmentRequestRequestExtend_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PlanAssignmentRequestRequestExtend_FieldSubPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestExtend_FieldPathArrayOfValues {
	return &PlanAssignmentRequestRequestExtend_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PlanAssignmentRequestRequestExtend_FieldSubPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestExtend_FieldPathArrayItemValue {
	return &PlanAssignmentRequestRequestExtend_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PlanAssignmentRequestRequestExtend_FieldPathValue allows storing values for Extend fields according to their type
type PlanAssignmentRequestRequestExtend_FieldPathValue interface {
	PlanAssignmentRequestRequestExtend_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PlanAssignmentRequest_Request_Extend)
	CompareWith(*PlanAssignmentRequest_Request_Extend) (cmp int, comparable bool)
}

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

func MustParsePlanAssignmentRequestRequestExtend_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestRequestExtend_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestRequestExtend_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestRequestExtend_FieldTerminalPathValue struct {
	PlanAssignmentRequestRequestExtend_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestExtend_FieldPathValue = (*PlanAssignmentRequestRequestExtend_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Extend' as interface{}
func (fpv *PlanAssignmentRequestRequestExtend_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PlanAssignmentRequestRequestExtend_FieldTerminalPathValue) AsAssignmentValue() (*plan_assignment.Reference, bool) {
	res, ok := fpv.value.(*plan_assignment.Reference)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequestExtend_FieldTerminalPathValue) AsAdditionsValue() ([]*common.Allowance, bool) {
	res, ok := fpv.value.([]*common.Allowance)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequestExtend_FieldTerminalPathValue) AsRegionalDistributionsValue() ([]*common.RegionalDistribution, bool) {
	res, ok := fpv.value.([]*common.RegionalDistribution)
	return res, ok
}

// SetTo stores value for selected field for object Extend
func (fpv *PlanAssignmentRequestRequestExtend_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest_Request_Extend) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_Request_Extend)
	}
	switch fpv.selector {
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
		(*target).Assignment = fpv.value.(*plan_assignment.Reference)
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
		(*target).Additions = fpv.value.([]*common.Allowance)
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
		(*target).RegionalDistributions = fpv.value.([]*common.RegionalDistribution)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PlanAssignmentRequestRequestExtend_FieldTerminalPathValue' with the value under path in 'PlanAssignmentRequest_Request_Extend'.
func (fpv *PlanAssignmentRequestRequestExtend_FieldTerminalPathValue) CompareWith(source *PlanAssignmentRequest_Request_Extend) (int, bool) {
	switch fpv.selector {
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
		leftValue := fpv.value.(*plan_assignment.Reference)
		rightValue := source.GetAssignment()
		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 PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
		return 0, false
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Extend: %d", fpv.selector))
	}
}

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

type PlanAssignmentRequestRequestExtend_FieldSubPathValue struct {
	PlanAssignmentRequestRequestExtend_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PlanAssignmentRequestRequestExtend_FieldPathValue = (*PlanAssignmentRequestRequestExtend_FieldSubPathValue)(nil)

func (fpvs *PlanAssignmentRequestRequestExtend_FieldSubPathValue) AsAdditionsPathValue() (common.Allowance_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.Allowance_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequestRequestExtend_FieldSubPathValue) AsRegionalDistributionsPathValue() (common.RegionalDistribution_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.RegionalDistribution_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParsePlanAssignmentRequestRequestExtend_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestRequestExtend_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestRequestExtend_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestRequestExtend_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestExtend_FieldPathArrayItemValue = (*PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object PlanAssignmentRequest_Request_Extend as interface{}
func (fpaiv *PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayItemValue) AsAdditionsItemValue() (*common.Allowance, bool) {
	res, ok := fpaiv.value.(*common.Allowance)
	return res, ok
}
func (fpaiv *PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayItemValue) AsRegionalDistributionsItemValue() (*common.RegionalDistribution, bool) {
	res, ok := fpaiv.value.(*common.RegionalDistribution)
	return res, ok
}

func (fpaiv *PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_Request_Extend) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Extend'
func (fpaiv *PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayItemValue) ContainsValue(source *PlanAssignmentRequest_Request_Extend) bool {
	slice := fpaiv.PlanAssignmentRequestRequestExtend_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 PlanAssignmentRequestRequestExtend_FieldSubPathArrayItemValue struct {
	PlanAssignmentRequestRequestExtend_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PlanAssignmentRequestRequestExtend_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PlanAssignmentRequestRequestExtend_FieldSubPathArrayItemValue) AsAdditionsPathItemValue() (common.Allowance_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.Allowance_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequestRequestExtend_FieldSubPathArrayItemValue) AsRegionalDistributionsPathItemValue() (common.RegionalDistribution_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.RegionalDistribution_FieldPathArrayItemValue)
	return res, ok
}

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

// PlanAssignmentRequestRequestExtend_FieldPathArrayOfValues allows storing slice of values for Extend fields according to their type
type PlanAssignmentRequestRequestExtend_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PlanAssignmentRequestRequestExtend_FieldPath
}

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

func MustParsePlanAssignmentRequestRequestExtend_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestRequestExtend_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestRequestExtend_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestRequestExtend_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestRequestExtend_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAssignment:
		for _, v := range fpaov.values.([]*plan_assignment.Reference) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorAdditions:
		for _, v := range fpaov.values.([][]*common.Allowance) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestExtend_FieldPathSelectorRegionalDistributions:
		for _, v := range fpaov.values.([][]*common.RegionalDistribution) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues) AsAssignmentArrayOfValues() ([]*plan_assignment.Reference, bool) {
	res, ok := fpaov.values.([]*plan_assignment.Reference)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues) AsAdditionsArrayOfValues() ([][]*common.Allowance, bool) {
	res, ok := fpaov.values.([][]*common.Allowance)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestExtend_FieldTerminalPathArrayOfValues) AsRegionalDistributionsArrayOfValues() ([][]*common.RegionalDistribution, bool) {
	res, ok := fpaov.values.([][]*common.RegionalDistribution)
	return res, ok
}

type PlanAssignmentRequestRequestExtend_FieldSubPathArrayOfValues struct {
	PlanAssignmentRequestRequestExtend_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PlanAssignmentRequestRequestExtend_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestExtend_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PlanAssignmentRequestRequestExtend_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PlanAssignmentRequestRequestExtend_FieldSubPathArrayOfValues) AsAdditionsPathArrayOfValues() (common.Allowance_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.Allowance_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequestRequestExtend_FieldSubPathArrayOfValues) AsRegionalDistributionsPathArrayOfValues() (common.RegionalDistribution_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.RegionalDistribution_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PlanAssignmentRequestRequestRedistribute_FieldPathSelector int32

const (
	PlanAssignmentRequestRequestRedistribute_FieldPathSelectorAssignment            PlanAssignmentRequestRequestRedistribute_FieldPathSelector = 0
	PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions PlanAssignmentRequestRequestRedistribute_FieldPathSelector = 1
)

func (s PlanAssignmentRequestRequestRedistribute_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorAssignment:
		return "assignment"
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions:
		return "regional_distributions"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Redistribute: %d", s))
	}
}

func BuildPlanAssignmentRequestRequestRedistribute_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestRequestRedistribute_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_Request_Redistribute")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "assignment":
			return &PlanAssignmentRequestRequestRedistribute_FieldTerminalPath{selector: PlanAssignmentRequestRequestRedistribute_FieldPathSelectorAssignment}, nil
		case "regional_distributions", "regionalDistributions", "regional-distributions":
			return &PlanAssignmentRequestRequestRedistribute_FieldTerminalPath{selector: PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions}, nil
		}
	} else {
		switch fp[0] {
		case "regional_distributions", "regionalDistributions", "regional-distributions":
			if subpath, err := common.BuildRegionalDistribution_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestRedistribute_FieldSubPath{selector: PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_Request_Redistribute", fp)
}

func ParsePlanAssignmentRequestRequestRedistribute_FieldPath(rawField string) (PlanAssignmentRequestRequestRedistribute_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestRequestRedistribute_FieldPath(fp)
}

func MustParsePlanAssignmentRequestRequestRedistribute_FieldPath(rawField string) PlanAssignmentRequestRequestRedistribute_FieldPath {
	fp, err := ParsePlanAssignmentRequestRequestRedistribute_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestRequestRedistribute_FieldTerminalPath struct {
	selector PlanAssignmentRequestRequestRedistribute_FieldPathSelector
}

var _ PlanAssignmentRequestRequestRedistribute_FieldPath = (*PlanAssignmentRequestRequestRedistribute_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestRequestRedistribute_FieldTerminalPath) Selector() PlanAssignmentRequestRequestRedistribute_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *PlanAssignmentRequestRequestRedistribute_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorAssignment:
		return (*plan_assignment.Reference)(nil)
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions:
		return ([]*common.RegionalDistribution)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Redistribute: %d", fp.selector))
	}
}

func (fp *PlanAssignmentRequestRequestRedistribute_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_Request_Redistribute) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorAssignment:
			item.Assignment = nil
		case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions:
			item.RegionalDistributions = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Redistribute: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestRequestRedistribute_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_Request_Redistribute))
}

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

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

func (fp *PlanAssignmentRequestRequestRedistribute_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestRequestRedistribute_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestRedistribute_FieldTerminalPathValue{PlanAssignmentRequestRequestRedistribute_FieldTerminalPath: *fp, value: value.(*plan_assignment.Reference)}
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions:
		return &PlanAssignmentRequestRequestRedistribute_FieldTerminalPathValue{PlanAssignmentRequestRequestRedistribute_FieldTerminalPath: *fp, value: value.([]*common.RegionalDistribution)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Redistribute: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestRequestRedistribute_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestRedistribute_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestRedistribute_FieldTerminalPath: *fp, values: values.([]*plan_assignment.Reference)}
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions:
		return &PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestRedistribute_FieldTerminalPath: *fp, values: values.([][]*common.RegionalDistribution)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Redistribute: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PlanAssignmentRequestRequestRedistribute_FieldTerminalPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestRedistribute_FieldPathArrayItemValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions:
		return &PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayItemValue{PlanAssignmentRequestRequestRedistribute_FieldTerminalPath: *fp, value: value.(*common.RegionalDistribution)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Redistribute: %d", fp.selector))
	}
}

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

type PlanAssignmentRequestRequestRedistribute_FieldSubPath struct {
	selector PlanAssignmentRequestRequestRedistribute_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PlanAssignmentRequestRequestRedistribute_FieldPath = (*PlanAssignmentRequestRequestRedistribute_FieldSubPath)(nil)

func (fps *PlanAssignmentRequestRequestRedistribute_FieldSubPath) Selector() PlanAssignmentRequestRequestRedistribute_FieldPathSelector {
	return fps.selector
}
func (fps *PlanAssignmentRequestRequestRedistribute_FieldSubPath) AsRegionalDistributionsSubPath() (common.RegionalDistribution_FieldPath, bool) {
	res, ok := fps.subPath.(common.RegionalDistribution_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *PlanAssignmentRequestRequestRedistribute_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PlanAssignmentRequest_Request_Redistribute))
}

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

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

func (fps *PlanAssignmentRequestRequestRedistribute_FieldSubPath) WithIValue(value interface{}) PlanAssignmentRequestRequestRedistribute_FieldPathValue {
	return &PlanAssignmentRequestRequestRedistribute_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PlanAssignmentRequestRequestRedistribute_FieldSubPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues {
	return &PlanAssignmentRequestRequestRedistribute_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PlanAssignmentRequestRequestRedistribute_FieldSubPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestRedistribute_FieldPathArrayItemValue {
	return &PlanAssignmentRequestRequestRedistribute_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PlanAssignmentRequestRequestRedistribute_FieldPathValue allows storing values for Redistribute fields according to their type
type PlanAssignmentRequestRequestRedistribute_FieldPathValue interface {
	PlanAssignmentRequestRequestRedistribute_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PlanAssignmentRequest_Request_Redistribute)
	CompareWith(*PlanAssignmentRequest_Request_Redistribute) (cmp int, comparable bool)
}

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

func MustParsePlanAssignmentRequestRequestRedistribute_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestRequestRedistribute_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestRequestRedistribute_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestRequestRedistribute_FieldTerminalPathValue struct {
	PlanAssignmentRequestRequestRedistribute_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestRedistribute_FieldPathValue = (*PlanAssignmentRequestRequestRedistribute_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Redistribute' as interface{}
func (fpv *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathValue) AsAssignmentValue() (*plan_assignment.Reference, bool) {
	res, ok := fpv.value.(*plan_assignment.Reference)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathValue) AsRegionalDistributionsValue() ([]*common.RegionalDistribution, bool) {
	res, ok := fpv.value.([]*common.RegionalDistribution)
	return res, ok
}

// SetTo stores value for selected field for object Redistribute
func (fpv *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest_Request_Redistribute) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_Request_Redistribute)
	}
	switch fpv.selector {
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorAssignment:
		(*target).Assignment = fpv.value.(*plan_assignment.Reference)
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions:
		(*target).RegionalDistributions = fpv.value.([]*common.RegionalDistribution)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Redistribute: %d", fpv.selector))
	}
}

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

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

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

type PlanAssignmentRequestRequestRedistribute_FieldSubPathValue struct {
	PlanAssignmentRequestRequestRedistribute_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PlanAssignmentRequestRequestRedistribute_FieldPathValue = (*PlanAssignmentRequestRequestRedistribute_FieldSubPathValue)(nil)

func (fpvs *PlanAssignmentRequestRequestRedistribute_FieldSubPathValue) AsRegionalDistributionsPathValue() (common.RegionalDistribution_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.RegionalDistribution_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParsePlanAssignmentRequestRequestRedistribute_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestRequestRedistribute_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestRequestRedistribute_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestRequestRedistribute_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestRedistribute_FieldPathArrayItemValue = (*PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object PlanAssignmentRequest_Request_Redistribute as interface{}
func (fpaiv *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayItemValue) AsRegionalDistributionsItemValue() (*common.RegionalDistribution, bool) {
	res, ok := fpaiv.value.(*common.RegionalDistribution)
	return res, ok
}

func (fpaiv *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_Request_Redistribute) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Redistribute'
func (fpaiv *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayItemValue) ContainsValue(source *PlanAssignmentRequest_Request_Redistribute) bool {
	slice := fpaiv.PlanAssignmentRequestRequestRedistribute_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 PlanAssignmentRequestRequestRedistribute_FieldSubPathArrayItemValue struct {
	PlanAssignmentRequestRequestRedistribute_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PlanAssignmentRequestRequestRedistribute_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PlanAssignmentRequestRequestRedistribute_FieldSubPathArrayItemValue) AsRegionalDistributionsPathItemValue() (common.RegionalDistribution_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.RegionalDistribution_FieldPathArrayItemValue)
	return res, ok
}

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

// PlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues allows storing slice of values for Redistribute fields according to their type
type PlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PlanAssignmentRequestRequestRedistribute_FieldPath
}

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

func MustParsePlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestRequestRedistribute_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorAssignment:
		for _, v := range fpaov.values.([]*plan_assignment.Reference) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestRedistribute_FieldPathSelectorRegionalDistributions:
		for _, v := range fpaov.values.([][]*common.RegionalDistribution) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayOfValues) AsAssignmentArrayOfValues() ([]*plan_assignment.Reference, bool) {
	res, ok := fpaov.values.([]*plan_assignment.Reference)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestRedistribute_FieldTerminalPathArrayOfValues) AsRegionalDistributionsArrayOfValues() ([][]*common.RegionalDistribution, bool) {
	res, ok := fpaov.values.([][]*common.RegionalDistribution)
	return res, ok
}

type PlanAssignmentRequestRequestRedistribute_FieldSubPathArrayOfValues struct {
	PlanAssignmentRequestRequestRedistribute_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PlanAssignmentRequestRequestRedistribute_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestRedistribute_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PlanAssignmentRequestRequestRedistribute_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PlanAssignmentRequestRequestRedistribute_FieldSubPathArrayOfValues) AsRegionalDistributionsPathArrayOfValues() (common.RegionalDistribution_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.RegionalDistribution_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PlanAssignmentRequestRequestUnassign_FieldPathSelector int32

const (
	PlanAssignmentRequestRequestUnassign_FieldPathSelectorAssignment PlanAssignmentRequestRequestUnassign_FieldPathSelector = 0
)

func (s PlanAssignmentRequestRequestUnassign_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestRequestUnassign_FieldPathSelectorAssignment:
		return "assignment"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Unassign: %d", s))
	}
}

func BuildPlanAssignmentRequestRequestUnassign_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestRequestUnassign_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_Request_Unassign")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "assignment":
			return &PlanAssignmentRequestRequestUnassign_FieldTerminalPath{selector: PlanAssignmentRequestRequestUnassign_FieldPathSelectorAssignment}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_Request_Unassign", fp)
}

func ParsePlanAssignmentRequestRequestUnassign_FieldPath(rawField string) (PlanAssignmentRequestRequestUnassign_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestRequestUnassign_FieldPath(fp)
}

func MustParsePlanAssignmentRequestRequestUnassign_FieldPath(rawField string) PlanAssignmentRequestRequestUnassign_FieldPath {
	fp, err := ParsePlanAssignmentRequestRequestUnassign_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestRequestUnassign_FieldTerminalPath struct {
	selector PlanAssignmentRequestRequestUnassign_FieldPathSelector
}

var _ PlanAssignmentRequestRequestUnassign_FieldPath = (*PlanAssignmentRequestRequestUnassign_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestRequestUnassign_FieldTerminalPath) Selector() PlanAssignmentRequestRequestUnassign_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *PlanAssignmentRequestRequestUnassign_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_Request_Unassign) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestUnassign_FieldPathSelectorAssignment:
			item.Assignment = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Unassign: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestRequestUnassign_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_Request_Unassign))
}

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

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

func (fp *PlanAssignmentRequestRequestUnassign_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestRequestUnassign_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestUnassign_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestUnassign_FieldTerminalPathValue{PlanAssignmentRequestRequestUnassign_FieldTerminalPath: *fp, value: value.(*plan_assignment.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Unassign: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestRequestUnassign_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestUnassign_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestRequestUnassign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestUnassign_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestRequestUnassign_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestUnassign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestUnassign_FieldTerminalPath: *fp, values: values.([]*plan_assignment.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Unassign: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// PlanAssignmentRequestRequestUnassign_FieldPathValue allows storing values for Unassign fields according to their type
type PlanAssignmentRequestRequestUnassign_FieldPathValue interface {
	PlanAssignmentRequestRequestUnassign_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PlanAssignmentRequest_Request_Unassign)
	CompareWith(*PlanAssignmentRequest_Request_Unassign) (cmp int, comparable bool)
}

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

func MustParsePlanAssignmentRequestRequestUnassign_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestRequestUnassign_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestRequestUnassign_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestRequestUnassign_FieldTerminalPathValue struct {
	PlanAssignmentRequestRequestUnassign_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestUnassign_FieldPathValue = (*PlanAssignmentRequestRequestUnassign_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Unassign' as interface{}
func (fpv *PlanAssignmentRequestRequestUnassign_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PlanAssignmentRequestRequestUnassign_FieldTerminalPathValue) AsAssignmentValue() (*plan_assignment.Reference, bool) {
	res, ok := fpv.value.(*plan_assignment.Reference)
	return res, ok
}

// SetTo stores value for selected field for object Unassign
func (fpv *PlanAssignmentRequestRequestUnassign_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest_Request_Unassign) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_Request_Unassign)
	}
	switch fpv.selector {
	case PlanAssignmentRequestRequestUnassign_FieldPathSelectorAssignment:
		(*target).Assignment = fpv.value.(*plan_assignment.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_Request_Unassign: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PlanAssignmentRequestRequestUnassign_FieldTerminalPathValue' with the value under path in 'PlanAssignmentRequest_Request_Unassign'.
func (fpv *PlanAssignmentRequestRequestUnassign_FieldTerminalPathValue) CompareWith(source *PlanAssignmentRequest_Request_Unassign) (int, bool) {
	switch fpv.selector {
	case PlanAssignmentRequestRequestUnassign_FieldPathSelectorAssignment:
		leftValue := fpv.value.(*plan_assignment.Reference)
		rightValue := source.GetAssignment()
		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 PlanAssignmentRequest_Request_Unassign: %d", fpv.selector))
	}
}

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

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

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

func MustParsePlanAssignmentRequestRequestUnassign_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestRequestUnassign_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestRequestUnassign_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestRequestUnassign_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestRequestUnassign_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestUnassign_FieldPathArrayItemValue = (*PlanAssignmentRequestRequestUnassign_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PlanAssignmentRequestRequestUnassign_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_Request_Unassign) (interface{}, bool) {
	return nil, false
}

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

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

// PlanAssignmentRequestRequestUnassign_FieldPathArrayOfValues allows storing slice of values for Unassign fields according to their type
type PlanAssignmentRequestRequestUnassign_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PlanAssignmentRequestRequestUnassign_FieldPath
}

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

func MustParsePlanAssignmentRequestRequestUnassign_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestRequestUnassign_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestRequestUnassign_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestRequestUnassign_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestRequestUnassign_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestRequestUnassign_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestUnassign_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequestRequestUnassign_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequestRequestUnassign_FieldPathSelectorAssignment:
		for _, v := range fpaov.values.([]*plan_assignment.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequestRequestUnassign_FieldTerminalPathArrayOfValues) AsAssignmentArrayOfValues() ([]*plan_assignment.Reference, bool) {
	res, ok := fpaov.values.([]*plan_assignment.Reference)
	return res, ok
}