github.com/cloudwan/edgelq-sdk@v1.15.4/limits/resources/v1/plan_assignment_request/plan_assignment_request.pb.fieldpath.go

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

package plan_assignment_request

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

	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/encoding/protojson"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/reflect/protoregistry"

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

// proto imports
import (
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	accepted_plan "github.com/cloudwan/edgelq-sdk/limits/resources/v1/accepted_plan"
	common "github.com/cloudwan/edgelq-sdk/limits/resources/v1/common"
	plan "github.com/cloudwan/edgelq-sdk/limits/resources/v1/plan"
	plan_assignment "github.com/cloudwan/edgelq-sdk/limits/resources/v1/plan_assignment"
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
	meta "github.com/cloudwan/goten-sdk/types/meta"
)

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

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

	_ = new(gotenobject.FieldPath)
)

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

// 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_FieldPathSelectorMetadata PlanAssignmentRequest_FieldPathSelector = 1
	PlanAssignmentRequest_FieldPathSelectorRequest  PlanAssignmentRequest_FieldPathSelector = 2
	PlanAssignmentRequest_FieldPathSelectorService  PlanAssignmentRequest_FieldPathSelector = 3
	PlanAssignmentRequest_FieldPathSelectorApprover PlanAssignmentRequest_FieldPathSelector = 4
	PlanAssignmentRequest_FieldPathSelectorStatus   PlanAssignmentRequest_FieldPathSelector = 5
)

func (s PlanAssignmentRequest_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequest_FieldPathSelectorName:
		return "name"
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		return "metadata"
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return "request"
	case PlanAssignmentRequest_FieldPathSelectorService:
		return "service"
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		return "approver"
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return "status"
	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 "metadata":
			return &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorMetadata}, 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
		}
	} else {
		switch fp[0] {
		case "metadata":
			if subpath, err := meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequest_FieldSubPath{selector: PlanAssignmentRequest_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		case "request":
			if subpath, err := BuildPlanAssignmentRequestRequestType_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
			}
		}
	}
	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_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		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)
			}
		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_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		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
	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_FieldPathSelectorMetadata:
		return (*meta.Meta)(nil)
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return (*PlanAssignmentRequest_RequestType)(nil)
	case PlanAssignmentRequest_FieldPathSelectorService:
		return (*meta_service.Reference)(nil)
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		return (*accepted_plan.ParentName)(nil)
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return (*PlanAssignmentRequest_Status)(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_FieldPathSelectorMetadata:
			item.Metadata = 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
		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_FieldPathSelectorMetadata:
		return &PlanAssignmentRequest_FieldTerminalPathValue{PlanAssignmentRequest_FieldTerminalPath: *fp, value: value.(*meta.Meta)}
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return &PlanAssignmentRequest_FieldTerminalPathValue{PlanAssignmentRequest_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_RequestType)}
	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.(*accepted_plan.ParentName)}
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return &PlanAssignmentRequest_FieldTerminalPathValue{PlanAssignmentRequest_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_Status)}
	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_FieldPathSelectorMetadata:
		return &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp, values: values.([]*meta.Meta)}
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_RequestType)}
	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.([]*accepted_plan.ParentName)}
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return &PlanAssignmentRequest_FieldTerminalPathArrayOfValues{PlanAssignmentRequest_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_Status)}
	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) AsMetadataSubPath() (meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(meta.Meta_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequest_FieldSubPath) AsRequestSubPath() (PlanAssignmentRequestRequestType_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestRequestType_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequest_FieldSubPath) AsStatusSubPath() (PlanAssignmentRequestStatus_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestStatus_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_FieldPathSelectorMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetMetadata())...)
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		values = append(values, fps.subPath.GetRaw(source.GetRequest())...)
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		values = append(values, fps.subPath.GetRaw(source.GetStatus())...)
	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_FieldPathSelectorMetadata:
		if source.GetMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetadata())
	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())
	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_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		case PlanAssignmentRequest_FieldPathSelectorRequest:
			fps.subPath.ClearValueRaw(item.Request)
		case PlanAssignmentRequest_FieldPathSelectorStatus:
			fps.subPath.ClearValueRaw(item.Status)
		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) AsMetadataValue() (*meta.Meta, bool) {
	res, ok := fpv.value.(*meta.Meta)
	return res, ok
}
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) AsRequestValue() (*PlanAssignmentRequest_RequestType, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_RequestType)
	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() (*accepted_plan.ParentName, bool) {
	res, ok := fpv.value.(*accepted_plan.ParentName)
	return res, ok
}
func (fpv *PlanAssignmentRequest_FieldTerminalPathValue) AsStatusValue() (*PlanAssignmentRequest_Status, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_Status)
	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_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*meta.Meta)
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		(*target).Request = fpv.value.(*PlanAssignmentRequest_RequestType)
	case PlanAssignmentRequest_FieldPathSelectorService:
		(*target).Service = fpv.value.(*meta_service.Reference)
	case PlanAssignmentRequest_FieldPathSelectorApprover:
		(*target).Approver = fpv.value.(*accepted_plan.ParentName)
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(*PlanAssignmentRequest_Status)
	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_FieldPathSelectorMetadata:
		return 0, false
	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.(*accepted_plan.ParentName)
		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
	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) AsMetadataPathValue() (meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(meta.Meta_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequest_FieldSubPathValue) AsRequestPathValue() (PlanAssignmentRequestRequestType_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestRequestType_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) SetTo(target **PlanAssignmentRequest) {
	if *target == nil {
		*target = new(PlanAssignmentRequest)
	}
	switch fpvs.Selector() {
	case PlanAssignmentRequest_FieldPathSelectorMetadata:
		fpvs.subPathValue.(meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		fpvs.subPathValue.(PlanAssignmentRequestRequestType_FieldPathValue).SetTo(&(*target).Request)
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		fpvs.subPathValue.(PlanAssignmentRequestStatus_FieldPathValue).SetTo(&(*target).Status)
	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_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return fpvs.subPathValue.(PlanAssignmentRequestRequestType_FieldPathValue).CompareWith(source.GetRequest())
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return fpvs.subPathValue.(PlanAssignmentRequestStatus_FieldPathValue).CompareWith(source.GetStatus())
	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) AsMetadataPathItemValue() (meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequest_FieldSubPathArrayItemValue) AsRequestPathItemValue() (PlanAssignmentRequestRequestType_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestRequestType_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequest_FieldSubPathArrayItemValue) AsStatusPathItemValue() (PlanAssignmentRequestStatus_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestStatus_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_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestRequestType_FieldPathArrayItemValue).ContainsValue(source.GetRequest())
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestStatus_FieldPathArrayItemValue).ContainsValue(source.GetStatus())
	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_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*meta.Meta) {
			values = append(values, v)
		}
	case PlanAssignmentRequest_FieldPathSelectorRequest:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_RequestType) {
			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.([]*accepted_plan.ParentName) {
			values = append(values, v)
		}
	case PlanAssignmentRequest_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_Status) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*meta.Meta, bool) {
	res, ok := fpaov.values.([]*meta.Meta)
	return res, ok
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsRequestArrayOfValues() ([]*PlanAssignmentRequest_RequestType, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_RequestType)
	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() ([]*accepted_plan.ParentName, bool) {
	res, ok := fpaov.values.([]*accepted_plan.ParentName)
	return res, ok
}
func (fpaov *PlanAssignmentRequest_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]*PlanAssignmentRequest_Status, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_Status)
	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) AsMetadataPathArrayOfValues() (meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(meta.Meta_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequest_FieldSubPathArrayOfValues) AsRequestPathArrayOfValues() (PlanAssignmentRequestRequestType_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestRequestType_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequest_FieldSubPathArrayOfValues) AsStatusPathArrayOfValues() (PlanAssignmentRequestStatus_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestStatus_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 PlanAssignmentRequestRequestType_FieldPath interface {
	gotenobject.FieldPath
	Selector() PlanAssignmentRequestRequestType_FieldPathSelector
	Get(source *PlanAssignmentRequest_RequestType) []interface{}
	GetSingle(source *PlanAssignmentRequest_RequestType) (interface{}, bool)
	ClearValue(item *PlanAssignmentRequest_RequestType)

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

type PlanAssignmentRequestRequestType_FieldPathSelector int32

const (
	PlanAssignmentRequestRequestType_FieldPathSelectorAssign   PlanAssignmentRequestRequestType_FieldPathSelector = 0
	PlanAssignmentRequestRequestType_FieldPathSelectorExtend   PlanAssignmentRequestRequestType_FieldPathSelector = 1
	PlanAssignmentRequestRequestType_FieldPathSelectorUnassign PlanAssignmentRequestRequestType_FieldPathSelector = 2
)

func (s PlanAssignmentRequestRequestType_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		return "assign"
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		return "extend"
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		return "unassign"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", s))
	}
}

func BuildPlanAssignmentRequestRequestType_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestRequestType_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_RequestType")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "assign":
			return &PlanAssignmentRequestRequestType_FieldTerminalPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorAssign}, nil
		case "extend":
			return &PlanAssignmentRequestRequestType_FieldTerminalPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorExtend}, nil
		case "unassign":
			return &PlanAssignmentRequestRequestType_FieldTerminalPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorUnassign}, nil
		}
	} else {
		switch fp[0] {
		case "assign":
			if subpath, err := BuildPlanAssignmentRequestRequestTypeAssign_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestType_FieldSubPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorAssign, subPath: subpath}, nil
			}
		case "extend":
			if subpath, err := BuildPlanAssignmentRequestRequestTypeExtend_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestType_FieldSubPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorExtend, subPath: subpath}, nil
			}
		case "unassign":
			if subpath, err := BuildPlanAssignmentRequestRequestTypeUnassign_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestType_FieldSubPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorUnassign, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_RequestType", fp)
}

func ParsePlanAssignmentRequestRequestType_FieldPath(rawField string) (PlanAssignmentRequestRequestType_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestRequestType_FieldPath(fp)
}

func MustParsePlanAssignmentRequestRequestType_FieldPath(rawField string) PlanAssignmentRequestRequestType_FieldPath {
	fp, err := ParsePlanAssignmentRequestRequestType_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestRequestType_FieldTerminalPath struct {
	selector PlanAssignmentRequestRequestType_FieldPathSelector
}

var _ PlanAssignmentRequestRequestType_FieldPath = (*PlanAssignmentRequestRequestType_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestRequestType_FieldTerminalPath) Selector() PlanAssignmentRequestRequestType_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PlanAssignmentRequest_RequestType
func (fp *PlanAssignmentRequestRequestType_FieldTerminalPath) Get(source *PlanAssignmentRequest_RequestType) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
			if source, ok := source.Request.(*PlanAssignmentRequest_RequestType_Assign_); ok && source != nil {
				if source.Assign != nil {
					values = append(values, source.Assign)
				}
			}
		case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
			if source, ok := source.Request.(*PlanAssignmentRequest_RequestType_Extend_); ok && source != nil {
				if source.Extend != nil {
					values = append(values, source.Extend)
				}
			}
		case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
			if source, ok := source.Request.(*PlanAssignmentRequest_RequestType_Unassign_); ok && source != nil {
				if source.Unassign != nil {
					values = append(values, source.Unassign)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PlanAssignmentRequest_RequestType
func (fp *PlanAssignmentRequestRequestType_FieldTerminalPath) GetSingle(source *PlanAssignmentRequest_RequestType) (interface{}, bool) {
	switch fp.selector {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetAssign(), false
		}
		_, oneOfSelected := source.Request.(*PlanAssignmentRequest_RequestType_Assign_)
		if !oneOfSelected {
			return source.GetAssign(), false // to return "type" information
		}
		res := source.GetAssign()
		return res, res != nil
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetExtend(), false
		}
		_, oneOfSelected := source.Request.(*PlanAssignmentRequest_RequestType_Extend_)
		if !oneOfSelected {
			return source.GetExtend(), false // to return "type" information
		}
		res := source.GetExtend()
		return res, res != nil
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetUnassign(), false
		}
		_, oneOfSelected := source.Request.(*PlanAssignmentRequest_RequestType_Unassign_)
		if !oneOfSelected {
			return source.GetUnassign(), false // to return "type" information
		}
		res := source.GetUnassign()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PlanAssignmentRequestRequestType_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		return (*PlanAssignmentRequest_RequestType_Assign)(nil)
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		return (*PlanAssignmentRequest_RequestType_Extend)(nil)
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		return (*PlanAssignmentRequest_RequestType_Unassign)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fp.selector))
	}
}

func (fp *PlanAssignmentRequestRequestType_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_RequestType) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
			if item, ok := item.Request.(*PlanAssignmentRequest_RequestType_Assign_); ok {
				item.Assign = nil
			}
		case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
			if item, ok := item.Request.(*PlanAssignmentRequest_RequestType_Extend_); ok {
				item.Extend = nil
			}
		case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
			if item, ok := item.Request.(*PlanAssignmentRequest_RequestType_Unassign_); ok {
				item.Unassign = nil
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestRequestType_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_RequestType))
}

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

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

func (fp *PlanAssignmentRequestRequestType_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestRequestType_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		return &PlanAssignmentRequestRequestType_FieldTerminalPathValue{PlanAssignmentRequestRequestType_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_RequestType_Assign)}
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		return &PlanAssignmentRequestRequestType_FieldTerminalPathValue{PlanAssignmentRequestRequestType_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_RequestType_Extend)}
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		return &PlanAssignmentRequestRequestType_FieldTerminalPathValue{PlanAssignmentRequestRequestType_FieldTerminalPath: *fp, value: value.(*PlanAssignmentRequest_RequestType_Unassign)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestRequestType_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestType_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestType_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		return &PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestType_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_RequestType_Assign)}
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		return &PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestType_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_RequestType_Extend)}
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		return &PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestType_FieldTerminalPath: *fp, values: values.([]*PlanAssignmentRequest_RequestType_Unassign)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type PlanAssignmentRequestRequestType_FieldSubPath struct {
	selector PlanAssignmentRequestRequestType_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PlanAssignmentRequestRequestType_FieldPath = (*PlanAssignmentRequestRequestType_FieldSubPath)(nil)

func (fps *PlanAssignmentRequestRequestType_FieldSubPath) Selector() PlanAssignmentRequestRequestType_FieldPathSelector {
	return fps.selector
}
func (fps *PlanAssignmentRequestRequestType_FieldSubPath) AsAssignSubPath() (PlanAssignmentRequestRequestTypeAssign_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestRequestTypeAssign_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequestRequestType_FieldSubPath) AsExtendSubPath() (PlanAssignmentRequestRequestTypeExtend_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestRequestTypeExtend_FieldPath)
	return res, ok
}
func (fps *PlanAssignmentRequestRequestType_FieldSubPath) AsUnassignSubPath() (PlanAssignmentRequestRequestTypeUnassign_FieldPath, bool) {
	res, ok := fps.subPath.(PlanAssignmentRequestRequestTypeUnassign_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source PlanAssignmentRequest_RequestType
func (fps *PlanAssignmentRequestRequestType_FieldSubPath) Get(source *PlanAssignmentRequest_RequestType) (values []interface{}) {
	switch fps.selector {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		values = append(values, fps.subPath.GetRaw(source.GetAssign())...)
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		values = append(values, fps.subPath.GetRaw(source.GetExtend())...)
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		values = append(values, fps.subPath.GetRaw(source.GetUnassign())...)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source PlanAssignmentRequest_RequestType
func (fps *PlanAssignmentRequestRequestType_FieldSubPath) GetSingle(source *PlanAssignmentRequest_RequestType) (interface{}, bool) {
	switch fps.selector {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		if source.GetAssign() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAssign())
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		if source.GetExtend() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetExtend())
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		if source.GetUnassign() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetUnassign())
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fps.selector))
	}
}

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

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

func (fps *PlanAssignmentRequestRequestType_FieldSubPath) ClearValue(item *PlanAssignmentRequest_RequestType) {
	if item != nil {
		switch fps.selector {
		case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
			if item.Request != nil {
				if item, ok := item.Request.(*PlanAssignmentRequest_RequestType_Assign_); ok {
					fps.subPath.ClearValueRaw(item.Assign)
				}
			}
		case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
			if item.Request != nil {
				if item, ok := item.Request.(*PlanAssignmentRequest_RequestType_Extend_); ok {
					fps.subPath.ClearValueRaw(item.Extend)
				}
			}
		case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
			if item.Request != nil {
				if item, ok := item.Request.(*PlanAssignmentRequest_RequestType_Unassign_); ok {
					fps.subPath.ClearValueRaw(item.Unassign)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fps.selector))
		}
	}
}

func (fps *PlanAssignmentRequestRequestType_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PlanAssignmentRequest_RequestType))
}

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

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

func (fps *PlanAssignmentRequestRequestType_FieldSubPath) WithIValue(value interface{}) PlanAssignmentRequestRequestType_FieldPathValue {
	return &PlanAssignmentRequestRequestType_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PlanAssignmentRequestRequestType_FieldSubPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestType_FieldPathArrayOfValues {
	return &PlanAssignmentRequestRequestType_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PlanAssignmentRequestRequestType_FieldSubPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestType_FieldPathArrayItemValue {
	return &PlanAssignmentRequestRequestType_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// PlanAssignmentRequestRequestType_FieldPathValue allows storing values for RequestType fields according to their type
type PlanAssignmentRequestRequestType_FieldPathValue interface {
	PlanAssignmentRequestRequestType_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **PlanAssignmentRequest_RequestType)
	CompareWith(*PlanAssignmentRequest_RequestType) (cmp int, comparable bool)
}

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

func MustParsePlanAssignmentRequestRequestType_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestRequestType_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestRequestType_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestRequestType_FieldTerminalPathValue struct {
	PlanAssignmentRequestRequestType_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestType_FieldPathValue = (*PlanAssignmentRequestRequestType_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RequestType' as interface{}
func (fpv *PlanAssignmentRequestRequestType_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PlanAssignmentRequestRequestType_FieldTerminalPathValue) AsAssignValue() (*PlanAssignmentRequest_RequestType_Assign, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_RequestType_Assign)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequestType_FieldTerminalPathValue) AsExtendValue() (*PlanAssignmentRequest_RequestType_Extend, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_RequestType_Extend)
	return res, ok
}
func (fpv *PlanAssignmentRequestRequestType_FieldTerminalPathValue) AsUnassignValue() (*PlanAssignmentRequest_RequestType_Unassign, bool) {
	res, ok := fpv.value.(*PlanAssignmentRequest_RequestType_Unassign)
	return res, ok
}

// SetTo stores value for selected field for object RequestType
func (fpv *PlanAssignmentRequestRequestType_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest_RequestType) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_RequestType)
	}
	switch fpv.selector {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_RequestType_Assign_); !ok {
			(*target).Request = &PlanAssignmentRequest_RequestType_Assign_{}
		}
		(*target).Request.(*PlanAssignmentRequest_RequestType_Assign_).Assign = fpv.value.(*PlanAssignmentRequest_RequestType_Assign)
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_RequestType_Extend_); !ok {
			(*target).Request = &PlanAssignmentRequest_RequestType_Extend_{}
		}
		(*target).Request.(*PlanAssignmentRequest_RequestType_Extend_).Extend = fpv.value.(*PlanAssignmentRequest_RequestType_Extend)
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_RequestType_Unassign_); !ok {
			(*target).Request = &PlanAssignmentRequest_RequestType_Unassign_{}
		}
		(*target).Request.(*PlanAssignmentRequest_RequestType_Unassign_).Unassign = fpv.value.(*PlanAssignmentRequest_RequestType_Unassign)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fpv.selector))
	}
}

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

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

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

type PlanAssignmentRequestRequestType_FieldSubPathValue struct {
	PlanAssignmentRequestRequestType_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PlanAssignmentRequestRequestType_FieldPathValue = (*PlanAssignmentRequestRequestType_FieldSubPathValue)(nil)

func (fpvs *PlanAssignmentRequestRequestType_FieldSubPathValue) AsAssignPathValue() (PlanAssignmentRequestRequestTypeAssign_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestRequestTypeAssign_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequestRequestType_FieldSubPathValue) AsExtendPathValue() (PlanAssignmentRequestRequestTypeExtend_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestRequestTypeExtend_FieldPathValue)
	return res, ok
}
func (fpvs *PlanAssignmentRequestRequestType_FieldSubPathValue) AsUnassignPathValue() (PlanAssignmentRequestRequestTypeUnassign_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PlanAssignmentRequestRequestTypeUnassign_FieldPathValue)
	return res, ok
}

func (fpvs *PlanAssignmentRequestRequestType_FieldSubPathValue) SetTo(target **PlanAssignmentRequest_RequestType) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_RequestType)
	}
	switch fpvs.Selector() {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_RequestType_Assign_); !ok {
			(*target).Request = &PlanAssignmentRequest_RequestType_Assign_{}
		}
		fpvs.subPathValue.(PlanAssignmentRequestRequestTypeAssign_FieldPathValue).SetTo(&(*target).Request.(*PlanAssignmentRequest_RequestType_Assign_).Assign)
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_RequestType_Extend_); !ok {
			(*target).Request = &PlanAssignmentRequest_RequestType_Extend_{}
		}
		fpvs.subPathValue.(PlanAssignmentRequestRequestTypeExtend_FieldPathValue).SetTo(&(*target).Request.(*PlanAssignmentRequest_RequestType_Extend_).Extend)
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		if _, ok := (*target).Request.(*PlanAssignmentRequest_RequestType_Unassign_); !ok {
			(*target).Request = &PlanAssignmentRequest_RequestType_Unassign_{}
		}
		fpvs.subPathValue.(PlanAssignmentRequestRequestTypeUnassign_FieldPathValue).SetTo(&(*target).Request.(*PlanAssignmentRequest_RequestType_Unassign_).Unassign)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PlanAssignmentRequestRequestType_FieldSubPathValue) CompareWith(source *PlanAssignmentRequest_RequestType) (int, bool) {
	switch fpvs.Selector() {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		return fpvs.subPathValue.(PlanAssignmentRequestRequestTypeAssign_FieldPathValue).CompareWith(source.GetAssign())
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		return fpvs.subPathValue.(PlanAssignmentRequestRequestTypeExtend_FieldPathValue).CompareWith(source.GetExtend())
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		return fpvs.subPathValue.(PlanAssignmentRequestRequestTypeUnassign_FieldPathValue).CompareWith(source.GetUnassign())
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePlanAssignmentRequestRequestType_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestRequestType_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestRequestType_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestRequestType_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestRequestType_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestType_FieldPathArrayItemValue = (*PlanAssignmentRequestRequestType_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PlanAssignmentRequestRequestType_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_RequestType) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'RequestType'
func (fpaiv *PlanAssignmentRequestRequestType_FieldTerminalPathArrayItemValue) ContainsValue(source *PlanAssignmentRequest_RequestType) bool {
	slice := fpaiv.PlanAssignmentRequestRequestType_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 PlanAssignmentRequestRequestType_FieldSubPathArrayItemValue struct {
	PlanAssignmentRequestRequestType_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PlanAssignmentRequestRequestType_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PlanAssignmentRequestRequestType_FieldSubPathArrayItemValue) AsAssignPathItemValue() (PlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequestRequestType_FieldSubPathArrayItemValue) AsExtendPathItemValue() (PlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PlanAssignmentRequestRequestType_FieldSubPathArrayItemValue) AsUnassignPathItemValue() (PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'RequestType'
func (fpaivs *PlanAssignmentRequestRequestType_FieldSubPathArrayItemValue) ContainsValue(source *PlanAssignmentRequest_RequestType) bool {
	switch fpaivs.Selector() {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue).ContainsValue(source.GetAssign())
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue).ContainsValue(source.GetExtend())
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		return fpaivs.subPathItemValue.(PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue).ContainsValue(source.GetUnassign())
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType: %d", fpaivs.Selector()))
	}
}

// PlanAssignmentRequestRequestType_FieldPathArrayOfValues allows storing slice of values for RequestType fields according to their type
type PlanAssignmentRequestRequestType_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PlanAssignmentRequestRequestType_FieldPath
}

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

func MustParsePlanAssignmentRequestRequestType_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestRequestType_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestRequestType_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestRequestType_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestRequestType_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequestRequestType_FieldPathSelectorAssign:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_RequestType_Assign) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestType_FieldPathSelectorExtend:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_RequestType_Extend) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign:
		for _, v := range fpaov.values.([]*PlanAssignmentRequest_RequestType_Unassign) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues) AsAssignArrayOfValues() ([]*PlanAssignmentRequest_RequestType_Assign, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_RequestType_Assign)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues) AsExtendArrayOfValues() ([]*PlanAssignmentRequest_RequestType_Extend, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_RequestType_Extend)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestType_FieldTerminalPathArrayOfValues) AsUnassignArrayOfValues() ([]*PlanAssignmentRequest_RequestType_Unassign, bool) {
	res, ok := fpaov.values.([]*PlanAssignmentRequest_RequestType_Unassign)
	return res, ok
}

type PlanAssignmentRequestRequestType_FieldSubPathArrayOfValues struct {
	PlanAssignmentRequestRequestType_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PlanAssignmentRequestRequestType_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestType_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PlanAssignmentRequestRequestType_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PlanAssignmentRequestRequestType_FieldSubPathArrayOfValues) AsAssignPathArrayOfValues() (PlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequestRequestType_FieldSubPathArrayOfValues) AsExtendPathArrayOfValues() (PlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PlanAssignmentRequestRequestType_FieldSubPathArrayOfValues) AsUnassignPathArrayOfValues() (PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PlanAssignmentRequestRequestTypeAssign_FieldPathSelector int32

const (
	PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan       PlanAssignmentRequestRequestTypeAssign_FieldPathSelector = 0
	PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions PlanAssignmentRequestRequestTypeAssign_FieldPathSelector = 1
	PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion     PlanAssignmentRequestRequestTypeAssign_FieldPathSelector = 2
)

func (s PlanAssignmentRequestRequestTypeAssign_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan:
		return "plan"
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
		return "extensions"
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
		return "region"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Assign: %d", s))
	}
}

func BuildPlanAssignmentRequestRequestTypeAssign_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestRequestTypeAssign_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_RequestType_Assign")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "plan":
			return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan}, nil
		case "extensions":
			return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions}, nil
		case "region":
			return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion}, nil
		}
	} else {
		switch fp[0] {
		case "extensions":
			if subpath, err := common.BuildAllowance_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestTypeAssign_FieldSubPath{selector: PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_RequestType_Assign", fp)
}

func ParsePlanAssignmentRequestRequestTypeAssign_FieldPath(rawField string) (PlanAssignmentRequestRequestTypeAssign_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestRequestTypeAssign_FieldPath(fp)
}

func MustParsePlanAssignmentRequestRequestTypeAssign_FieldPath(rawField string) PlanAssignmentRequestRequestTypeAssign_FieldPath {
	fp, err := ParsePlanAssignmentRequestRequestTypeAssign_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath struct {
	selector PlanAssignmentRequestRequestTypeAssign_FieldPathSelector
}

var _ PlanAssignmentRequestRequestTypeAssign_FieldPath = (*PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) Selector() PlanAssignmentRequestRequestTypeAssign_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PlanAssignmentRequest_RequestType_Assign
func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) Get(source *PlanAssignmentRequest_RequestType_Assign) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan:
			if source.Plan != nil {
				values = append(values, source.Plan)
			}
		case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
			for _, value := range source.GetExtensions() {
				values = append(values, value)
			}
		case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
			values = append(values, source.Region)
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Assign: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PlanAssignmentRequest_RequestType_Assign
func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) GetSingle(source *PlanAssignmentRequest_RequestType_Assign) (interface{}, bool) {
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan:
		res := source.GetPlan()
		return res, res != nil
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
		res := source.GetExtensions()
		return res, res != nil
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
		return source.GetRegion(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Assign: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan:
		return (*plan.Reference)(nil)
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
		return ([]*common.Allowance)(nil)
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Assign: %d", fp.selector))
	}
}

func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_RequestType_Assign) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan:
			item.Plan = nil
		case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
			item.Extensions = nil
		case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
			item.Region = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Assign: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_RequestType_Assign))
}

// IsLeaf - whether field path is holds simple value
func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan ||
		fp.selector == PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion
}

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

func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestRequestTypeAssign_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan:
		return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathValue{PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: *fp, value: value.(*plan.Reference)}
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
		return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathValue{PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: *fp, value: value.([]*common.Allowance)}
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
		return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathValue{PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Assign: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan:
		return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: *fp, values: values.([]*plan.Reference)}
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
		return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: *fp, values: values.([][]*common.Allowance)}
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
		return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Assign: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
		return &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayItemValue{PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: *fp, value: value.(*common.Allowance)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Assign: %d", fp.selector))
	}
}

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

type PlanAssignmentRequestRequestTypeAssign_FieldSubPath struct {
	selector PlanAssignmentRequestRequestTypeAssign_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PlanAssignmentRequestRequestTypeAssign_FieldPath = (*PlanAssignmentRequestRequestTypeAssign_FieldSubPath)(nil)

func (fps *PlanAssignmentRequestRequestTypeAssign_FieldSubPath) Selector() PlanAssignmentRequestRequestTypeAssign_FieldPathSelector {
	return fps.selector
}
func (fps *PlanAssignmentRequestRequestTypeAssign_FieldSubPath) AsExtensionsSubPath() (common.Allowance_FieldPath, bool) {
	res, ok := fps.subPath.(common.Allowance_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *PlanAssignmentRequestRequestTypeAssign_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PlanAssignmentRequest_RequestType_Assign))
}

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

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

func (fps *PlanAssignmentRequestRequestTypeAssign_FieldSubPath) WithIValue(value interface{}) PlanAssignmentRequestRequestTypeAssign_FieldPathValue {
	return &PlanAssignmentRequestRequestTypeAssign_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PlanAssignmentRequestRequestTypeAssign_FieldSubPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues {
	return &PlanAssignmentRequestRequestTypeAssign_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PlanAssignmentRequestRequestTypeAssign_FieldSubPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue {
	return &PlanAssignmentRequestRequestTypeAssign_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParsePlanAssignmentRequestRequestTypeAssign_FieldPathValue(pathStr, valueStr string) (PlanAssignmentRequestRequestTypeAssign_FieldPathValue, error) {
	fp, err := ParsePlanAssignmentRequestRequestTypeAssign_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.(PlanAssignmentRequestRequestTypeAssign_FieldPathValue), nil
}

func MustParsePlanAssignmentRequestRequestTypeAssign_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestRequestTypeAssign_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestRequestTypeAssign_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathValue struct {
	PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestTypeAssign_FieldPathValue = (*PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object Assign
func (fpv *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest_RequestType_Assign) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_RequestType_Assign)
	}
	switch fpv.selector {
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan:
		(*target).Plan = fpv.value.(*plan.Reference)
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
		(*target).Extensions = fpv.value.([]*common.Allowance)
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
		(*target).Region = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Assign: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathValue' with the value under path in 'PlanAssignmentRequest_RequestType_Assign'.
func (fpv *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathValue) CompareWith(source *PlanAssignmentRequest_RequestType_Assign) (int, bool) {
	switch fpv.selector {
	case PlanAssignmentRequestRequestTypeAssign_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 PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
		return 0, false
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
		leftValue := fpv.value.(string)
		rightValue := source.GetRegion()
		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_RequestType_Assign: %d", fpv.selector))
	}
}

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

type PlanAssignmentRequestRequestTypeAssign_FieldSubPathValue struct {
	PlanAssignmentRequestRequestTypeAssign_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PlanAssignmentRequestRequestTypeAssign_FieldPathValue = (*PlanAssignmentRequestRequestTypeAssign_FieldSubPathValue)(nil)

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

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

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

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

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

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

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

// ParsePlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParsePlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue(pathStr, valueStr string) (PlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue, error) {
	fp, err := ParsePlanAssignmentRequestRequestTypeAssign_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.(PlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue), nil
}

func MustParsePlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestTypeAssign_FieldPathArrayItemValue = (*PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_RequestType_Assign) (interface{}, bool) {
	return nil, false
}

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

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

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

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

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

func ParsePlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues(pathStr, valuesStr string) (PlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues, error) {
	fp, err := ParsePlanAssignmentRequestRequestTypeAssign_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.(PlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues), nil
}

func MustParsePlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan:
		for _, v := range fpaov.values.([]*plan.Reference) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions:
		for _, v := range fpaov.values.([][]*common.Allowance) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues) AsPlanArrayOfValues() ([]*plan.Reference, bool) {
	res, ok := fpaov.values.([]*plan.Reference)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues) AsExtensionsArrayOfValues() ([][]*common.Allowance, bool) {
	res, ok := fpaov.values.([][]*common.Allowance)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPathArrayOfValues) AsRegionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

type PlanAssignmentRequestRequestTypeAssign_FieldSubPathArrayOfValues struct {
	PlanAssignmentRequestRequestTypeAssign_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PlanAssignmentRequestRequestTypeAssign_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestTypeAssign_FieldSubPathArrayOfValues)(nil)

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

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

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

type PlanAssignmentRequestRequestTypeExtend_FieldPathSelector int32

const (
	PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment PlanAssignmentRequestRequestTypeExtend_FieldPathSelector = 0
	PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions  PlanAssignmentRequestRequestTypeExtend_FieldPathSelector = 1
)

func (s PlanAssignmentRequestRequestTypeExtend_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment:
		return "assignment"
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions:
		return "additions"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Extend: %d", s))
	}
}

func BuildPlanAssignmentRequestRequestTypeExtend_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestRequestTypeExtend_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_RequestType_Extend")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "assignment":
			return &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment}, nil
		case "additions":
			return &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions}, nil
		}
	} else {
		switch fp[0] {
		case "additions":
			if subpath, err := common.BuildAllowance_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PlanAssignmentRequestRequestTypeExtend_FieldSubPath{selector: PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_RequestType_Extend", fp)
}

func ParsePlanAssignmentRequestRequestTypeExtend_FieldPath(rawField string) (PlanAssignmentRequestRequestTypeExtend_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestRequestTypeExtend_FieldPath(fp)
}

func MustParsePlanAssignmentRequestRequestTypeExtend_FieldPath(rawField string) PlanAssignmentRequestRequestTypeExtend_FieldPath {
	fp, err := ParsePlanAssignmentRequestRequestTypeExtend_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath struct {
	selector PlanAssignmentRequestRequestTypeExtend_FieldPathSelector
}

var _ PlanAssignmentRequestRequestTypeExtend_FieldPath = (*PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath) Selector() PlanAssignmentRequestRequestTypeExtend_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_RequestType_Extend) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment:
			item.Assignment = nil
		case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions:
			item.Additions = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Extend: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_RequestType_Extend))
}

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

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

func (fp *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestRequestTypeExtend_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathValue{PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath: *fp, value: value.(*plan_assignment.Reference)}
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions:
		return &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathValue{PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath: *fp, value: value.([]*common.Allowance)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Extend: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath: *fp, values: values.([]*plan_assignment.Reference)}
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions:
		return &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath: *fp, values: values.([][]*common.Allowance)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Extend: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions:
		return &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayItemValue{PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath: *fp, value: value.(*common.Allowance)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Extend: %d", fp.selector))
	}
}

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

type PlanAssignmentRequestRequestTypeExtend_FieldSubPath struct {
	selector PlanAssignmentRequestRequestTypeExtend_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PlanAssignmentRequestRequestTypeExtend_FieldPath = (*PlanAssignmentRequestRequestTypeExtend_FieldSubPath)(nil)

func (fps *PlanAssignmentRequestRequestTypeExtend_FieldSubPath) Selector() PlanAssignmentRequestRequestTypeExtend_FieldPathSelector {
	return fps.selector
}
func (fps *PlanAssignmentRequestRequestTypeExtend_FieldSubPath) AsAdditionsSubPath() (common.Allowance_FieldPath, bool) {
	res, ok := fps.subPath.(common.Allowance_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *PlanAssignmentRequestRequestTypeExtend_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PlanAssignmentRequest_RequestType_Extend))
}

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

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

func (fps *PlanAssignmentRequestRequestTypeExtend_FieldSubPath) WithIValue(value interface{}) PlanAssignmentRequestRequestTypeExtend_FieldPathValue {
	return &PlanAssignmentRequestRequestTypeExtend_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PlanAssignmentRequestRequestTypeExtend_FieldSubPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues {
	return &PlanAssignmentRequestRequestTypeExtend_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PlanAssignmentRequestRequestTypeExtend_FieldSubPath) WithIArrayItemValue(value interface{}) PlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue {
	return &PlanAssignmentRequestRequestTypeExtend_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParsePlanAssignmentRequestRequestTypeExtend_FieldPathValue(pathStr, valueStr string) (PlanAssignmentRequestRequestTypeExtend_FieldPathValue, error) {
	fp, err := ParsePlanAssignmentRequestRequestTypeExtend_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.(PlanAssignmentRequestRequestTypeExtend_FieldPathValue), nil
}

func MustParsePlanAssignmentRequestRequestTypeExtend_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestRequestTypeExtend_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestRequestTypeExtend_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathValue struct {
	PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestTypeExtend_FieldPathValue = (*PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object Extend
func (fpv *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathValue) SetTo(target **PlanAssignmentRequest_RequestType_Extend) {
	if *target == nil {
		*target = new(PlanAssignmentRequest_RequestType_Extend)
	}
	switch fpv.selector {
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment:
		(*target).Assignment = fpv.value.(*plan_assignment.Reference)
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions:
		(*target).Additions = fpv.value.([]*common.Allowance)
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Extend: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathValue' with the value under path in 'PlanAssignmentRequest_RequestType_Extend'.
func (fpv *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathValue) CompareWith(source *PlanAssignmentRequest_RequestType_Extend) (int, bool) {
	switch fpv.selector {
	case PlanAssignmentRequestRequestTypeExtend_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 PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Extend: %d", fpv.selector))
	}
}

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

type PlanAssignmentRequestRequestTypeExtend_FieldSubPathValue struct {
	PlanAssignmentRequestRequestTypeExtend_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PlanAssignmentRequestRequestTypeExtend_FieldPathValue = (*PlanAssignmentRequestRequestTypeExtend_FieldSubPathValue)(nil)

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

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

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

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

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

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

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

// ParsePlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParsePlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue(pathStr, valueStr string) (PlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue, error) {
	fp, err := ParsePlanAssignmentRequestRequestTypeExtend_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.(PlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue), nil
}

func MustParsePlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestTypeExtend_FieldPathArrayItemValue = (*PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_RequestType_Extend) (interface{}, bool) {
	return nil, false
}

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

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

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

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

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

func ParsePlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues(pathStr, valuesStr string) (PlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues, error) {
	fp, err := ParsePlanAssignmentRequestRequestTypeExtend_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.(PlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues), nil
}

func MustParsePlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment:
		for _, v := range fpaov.values.([]*plan_assignment.Reference) {
			values = append(values, v)
		}
	case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions:
		for _, v := range fpaov.values.([][]*common.Allowance) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayOfValues) AsAssignmentArrayOfValues() ([]*plan_assignment.Reference, bool) {
	res, ok := fpaov.values.([]*plan_assignment.Reference)
	return res, ok
}
func (fpaov *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPathArrayOfValues) AsAdditionsArrayOfValues() ([][]*common.Allowance, bool) {
	res, ok := fpaov.values.([][]*common.Allowance)
	return res, ok
}

type PlanAssignmentRequestRequestTypeExtend_FieldSubPathArrayOfValues struct {
	PlanAssignmentRequestRequestTypeExtend_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PlanAssignmentRequestRequestTypeExtend_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestTypeExtend_FieldSubPathArrayOfValues)(nil)

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

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

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

type PlanAssignmentRequestRequestTypeUnassign_FieldPathSelector int32

const (
	PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorAssignment PlanAssignmentRequestRequestTypeUnassign_FieldPathSelector = 0
	PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorRegion     PlanAssignmentRequestRequestTypeUnassign_FieldPathSelector = 1
)

func (s PlanAssignmentRequestRequestTypeUnassign_FieldPathSelector) String() string {
	switch s {
	case PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorAssignment:
		return "assignment"
	case PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorRegion:
		return "region"
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Unassign: %d", s))
	}
}

func BuildPlanAssignmentRequestRequestTypeUnassign_FieldPath(fp gotenobject.RawFieldPath) (PlanAssignmentRequestRequestTypeUnassign_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PlanAssignmentRequest_RequestType_Unassign")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "assignment":
			return &PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorAssignment}, nil
		case "region":
			return &PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorRegion}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PlanAssignmentRequest_RequestType_Unassign", fp)
}

func ParsePlanAssignmentRequestRequestTypeUnassign_FieldPath(rawField string) (PlanAssignmentRequestRequestTypeUnassign_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPlanAssignmentRequestRequestTypeUnassign_FieldPath(fp)
}

func MustParsePlanAssignmentRequestRequestTypeUnassign_FieldPath(rawField string) PlanAssignmentRequestRequestTypeUnassign_FieldPath {
	fp, err := ParsePlanAssignmentRequestRequestTypeUnassign_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath struct {
	selector PlanAssignmentRequestRequestTypeUnassign_FieldPathSelector
}

var _ PlanAssignmentRequestRequestTypeUnassign_FieldPath = (*PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath)(nil)

func (fp *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath) Selector() PlanAssignmentRequestRequestTypeUnassign_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath) ClearValue(item *PlanAssignmentRequest_RequestType_Unassign) {
	if item != nil {
		switch fp.selector {
		case PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorAssignment:
			item.Assignment = nil
		case PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorRegion:
			item.Region = ""
		default:
			panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Unassign: %d", fp.selector))
		}
	}
}

func (fp *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PlanAssignmentRequest_RequestType_Unassign))
}

// IsLeaf - whether field path is holds simple value
func (fp *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorAssignment ||
		fp.selector == PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorRegion
}

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

func (fp *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath) WithIValue(value interface{}) PlanAssignmentRequestRequestTypeUnassign_FieldPathValue {
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathValue{PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath: *fp, value: value.(*plan_assignment.Reference)}
	case PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorRegion:
		return &PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathValue{PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Unassign: %d", fp.selector))
	}
}

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

func (fp *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath) WithIArrayOfValues(values interface{}) PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues {
	fpaov := &PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath: *fp}
	switch fp.selector {
	case PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorAssignment:
		return &PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath: *fp, values: values.([]*plan_assignment.Reference)}
	case PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorRegion:
		return &PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathArrayOfValues{PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for PlanAssignmentRequest_RequestType_Unassign: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParsePlanAssignmentRequestRequestTypeUnassign_FieldPathValue(pathStr, valueStr string) (PlanAssignmentRequestRequestTypeUnassign_FieldPathValue, error) {
	fp, err := ParsePlanAssignmentRequestRequestTypeUnassign_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.(PlanAssignmentRequestRequestTypeUnassign_FieldPathValue), nil
}

func MustParsePlanAssignmentRequestRequestTypeUnassign_FieldPathValue(pathStr, valueStr string) PlanAssignmentRequestRequestTypeUnassign_FieldPathValue {
	fpv, err := ParsePlanAssignmentRequestRequestTypeUnassign_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathValue struct {
	PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestTypeUnassign_FieldPathValue = (*PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathValue)(nil)

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

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

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

// CompareWith compares value in the 'PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathValue' with the value under path in 'PlanAssignmentRequest_RequestType_Unassign'.
func (fpv *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathValue) CompareWith(source *PlanAssignmentRequest_RequestType_Unassign) (int, bool) {
	switch fpv.selector {
	case PlanAssignmentRequestRequestTypeUnassign_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 PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorRegion:
		leftValue := fpv.value.(string)
		rightValue := source.GetRegion()
		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_RequestType_Unassign: %d", fpv.selector))
	}
}

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

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

// ParsePlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParsePlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue(pathStr, valueStr string) (PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue, error) {
	fp, err := ParsePlanAssignmentRequestRequestTypeUnassign_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.(PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue), nil
}

func MustParsePlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue(pathStr, valueStr string) PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue {
	fpaiv, err := ParsePlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathArrayItemValue struct {
	PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath
	value interface{}
}

var _ PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayItemValue = (*PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathArrayItemValue) GetSingle(source *PlanAssignmentRequest_RequestType_Unassign) (interface{}, bool) {
	return nil, false
}

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

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

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

func ParsePlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues(pathStr, valuesStr string) (PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues, error) {
	fp, err := ParsePlanAssignmentRequestRequestTypeUnassign_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.(PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues), nil
}

func MustParsePlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues(pathStr, valuesStr string) PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues {
	fpaov, err := ParsePlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathArrayOfValues struct {
	PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath
	values interface{}
}

var _ PlanAssignmentRequestRequestTypeUnassign_FieldPathArrayOfValues = (*PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPathArrayOfValues)(nil)

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