organization_invitation_custom.pb.fieldpath.go

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

package organization_invitation_client

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

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

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

// proto imports
import (
	organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha/organization"
	organization_invitation "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha/organization_invitation"
	project_invitation "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha/project_invitation"
)

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

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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &organization.Organization{}
	_ = &organization_invitation.OrganizationInvitation{}
	_ = &project_invitation.ProjectInvitation{}
)

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

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

type AcceptOrganizationInvitationRequest_FieldPathSelector int32

const (
	AcceptOrganizationInvitationRequest_FieldPathSelectorName AcceptOrganizationInvitationRequest_FieldPathSelector = 0
)

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

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

func ParseAcceptOrganizationInvitationRequest_FieldPath(rawField string) (AcceptOrganizationInvitationRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAcceptOrganizationInvitationRequest_FieldPath(fp)
}

func MustParseAcceptOrganizationInvitationRequest_FieldPath(rawField string) AcceptOrganizationInvitationRequest_FieldPath {
	fp, err := ParseAcceptOrganizationInvitationRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AcceptOrganizationInvitationRequest_FieldTerminalPath struct {
	selector AcceptOrganizationInvitationRequest_FieldPathSelector
}

var _ AcceptOrganizationInvitationRequest_FieldPath = (*AcceptOrganizationInvitationRequest_FieldTerminalPath)(nil)

func (fp *AcceptOrganizationInvitationRequest_FieldTerminalPath) Selector() AcceptOrganizationInvitationRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *AcceptOrganizationInvitationRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AcceptOrganizationInvitationRequest))
}

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

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

func (fp *AcceptOrganizationInvitationRequest_FieldTerminalPath) WithIValue(value interface{}) AcceptOrganizationInvitationRequest_FieldPathValue {
	switch fp.selector {
	case AcceptOrganizationInvitationRequest_FieldPathSelectorName:
		return &AcceptOrganizationInvitationRequest_FieldTerminalPathValue{AcceptOrganizationInvitationRequest_FieldTerminalPath: *fp, value: value.(*organization_invitation.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for AcceptOrganizationInvitationRequest: %d", fp.selector))
	}
}

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

func (fp *AcceptOrganizationInvitationRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) AcceptOrganizationInvitationRequest_FieldPathArrayOfValues {
	fpaov := &AcceptOrganizationInvitationRequest_FieldTerminalPathArrayOfValues{AcceptOrganizationInvitationRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case AcceptOrganizationInvitationRequest_FieldPathSelectorName:
		return &AcceptOrganizationInvitationRequest_FieldTerminalPathArrayOfValues{AcceptOrganizationInvitationRequest_FieldTerminalPath: *fp, values: values.([]*organization_invitation.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for AcceptOrganizationInvitationRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseAcceptOrganizationInvitationRequest_FieldPathValue(pathStr, valueStr string) AcceptOrganizationInvitationRequest_FieldPathValue {
	fpv, err := ParseAcceptOrganizationInvitationRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AcceptOrganizationInvitationRequest_FieldTerminalPathValue struct {
	AcceptOrganizationInvitationRequest_FieldTerminalPath
	value interface{}
}

var _ AcceptOrganizationInvitationRequest_FieldPathValue = (*AcceptOrganizationInvitationRequest_FieldTerminalPathValue)(nil)

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

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

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

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

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

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

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

func MustParseAcceptOrganizationInvitationRequest_FieldPathArrayItemValue(pathStr, valueStr string) AcceptOrganizationInvitationRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseAcceptOrganizationInvitationRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AcceptOrganizationInvitationRequest_FieldTerminalPathArrayItemValue struct {
	AcceptOrganizationInvitationRequest_FieldTerminalPath
	value interface{}
}

var _ AcceptOrganizationInvitationRequest_FieldPathArrayItemValue = (*AcceptOrganizationInvitationRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AcceptOrganizationInvitationRequest_FieldTerminalPathArrayItemValue) GetSingle(source *AcceptOrganizationInvitationRequest) (interface{}, bool) {
	return nil, false
}

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

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

// AcceptOrganizationInvitationRequest_FieldPathArrayOfValues allows storing slice of values for AcceptOrganizationInvitationRequest fields according to their type
type AcceptOrganizationInvitationRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AcceptOrganizationInvitationRequest_FieldPath
}

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

func MustParseAcceptOrganizationInvitationRequest_FieldPathArrayOfValues(pathStr, valuesStr string) AcceptOrganizationInvitationRequest_FieldPathArrayOfValues {
	fpaov, err := ParseAcceptOrganizationInvitationRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AcceptOrganizationInvitationRequest_FieldTerminalPathArrayOfValues struct {
	AcceptOrganizationInvitationRequest_FieldTerminalPath
	values interface{}
}

var _ AcceptOrganizationInvitationRequest_FieldPathArrayOfValues = (*AcceptOrganizationInvitationRequest_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type AcceptOrganizationInvitationResponse_FieldPathSelector int32

func (s AcceptOrganizationInvitationResponse_FieldPathSelector) String() string {
	switch s {
	default:
		panic(fmt.Sprintf("Invalid selector for AcceptOrganizationInvitationResponse: %d", s))
	}
}

func BuildAcceptOrganizationInvitationResponse_FieldPath(fp gotenobject.RawFieldPath) (AcceptOrganizationInvitationResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AcceptOrganizationInvitationResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AcceptOrganizationInvitationResponse", fp)
}

func ParseAcceptOrganizationInvitationResponse_FieldPath(rawField string) (AcceptOrganizationInvitationResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAcceptOrganizationInvitationResponse_FieldPath(fp)
}

func MustParseAcceptOrganizationInvitationResponse_FieldPath(rawField string) AcceptOrganizationInvitationResponse_FieldPath {
	fp, err := ParseAcceptOrganizationInvitationResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AcceptOrganizationInvitationResponse_FieldTerminalPath struct {
	selector AcceptOrganizationInvitationResponse_FieldPathSelector
}

var _ AcceptOrganizationInvitationResponse_FieldPath = (*AcceptOrganizationInvitationResponse_FieldTerminalPath)(nil)

func (fp *AcceptOrganizationInvitationResponse_FieldTerminalPath) Selector() AcceptOrganizationInvitationResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source AcceptOrganizationInvitationResponse
func (fp *AcceptOrganizationInvitationResponse_FieldTerminalPath) GetSingle(source *AcceptOrganizationInvitationResponse) (interface{}, bool) {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for AcceptOrganizationInvitationResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *AcceptOrganizationInvitationResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for AcceptOrganizationInvitationResponse: %d", fp.selector))
	}
}

func (fp *AcceptOrganizationInvitationResponse_FieldTerminalPath) ClearValue(item *AcceptOrganizationInvitationResponse) {
	if item != nil {
		switch fp.selector {
		default:
			panic(fmt.Sprintf("Invalid selector for AcceptOrganizationInvitationResponse: %d", fp.selector))
		}
	}
}

func (fp *AcceptOrganizationInvitationResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AcceptOrganizationInvitationResponse))
}

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

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

func (fp *AcceptOrganizationInvitationResponse_FieldTerminalPath) WithIValue(value interface{}) AcceptOrganizationInvitationResponse_FieldPathValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for AcceptOrganizationInvitationResponse: %d", fp.selector))
	}
}

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

func (fp *AcceptOrganizationInvitationResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) AcceptOrganizationInvitationResponse_FieldPathArrayOfValues {
	fpaov := &AcceptOrganizationInvitationResponse_FieldTerminalPathArrayOfValues{AcceptOrganizationInvitationResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for AcceptOrganizationInvitationResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseAcceptOrganizationInvitationResponse_FieldPathValue(pathStr, valueStr string) AcceptOrganizationInvitationResponse_FieldPathValue {
	fpv, err := ParseAcceptOrganizationInvitationResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AcceptOrganizationInvitationResponse_FieldTerminalPathValue struct {
	AcceptOrganizationInvitationResponse_FieldTerminalPath
	value interface{}
}

var _ AcceptOrganizationInvitationResponse_FieldPathValue = (*AcceptOrganizationInvitationResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AcceptOrganizationInvitationResponse' as interface{}
func (fpv *AcceptOrganizationInvitationResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}

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

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

// CompareWith compares value in the 'AcceptOrganizationInvitationResponse_FieldTerminalPathValue' with the value under path in 'AcceptOrganizationInvitationResponse'.
func (fpv *AcceptOrganizationInvitationResponse_FieldTerminalPathValue) CompareWith(source *AcceptOrganizationInvitationResponse) (int, bool) {
	switch fpv.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for AcceptOrganizationInvitationResponse: %d", fpv.selector))
	}
}

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

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

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

func MustParseAcceptOrganizationInvitationResponse_FieldPathArrayItemValue(pathStr, valueStr string) AcceptOrganizationInvitationResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseAcceptOrganizationInvitationResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AcceptOrganizationInvitationResponse_FieldTerminalPathArrayItemValue struct {
	AcceptOrganizationInvitationResponse_FieldTerminalPath
	value interface{}
}

var _ AcceptOrganizationInvitationResponse_FieldPathArrayItemValue = (*AcceptOrganizationInvitationResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AcceptOrganizationInvitationResponse_FieldTerminalPathArrayItemValue) GetSingle(source *AcceptOrganizationInvitationResponse) (interface{}, bool) {
	return nil, false
}

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

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

// AcceptOrganizationInvitationResponse_FieldPathArrayOfValues allows storing slice of values for AcceptOrganizationInvitationResponse fields according to their type
type AcceptOrganizationInvitationResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AcceptOrganizationInvitationResponse_FieldPath
}

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

func MustParseAcceptOrganizationInvitationResponse_FieldPathArrayOfValues(pathStr, valuesStr string) AcceptOrganizationInvitationResponse_FieldPathArrayOfValues {
	fpaov, err := ParseAcceptOrganizationInvitationResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AcceptOrganizationInvitationResponse_FieldTerminalPathArrayOfValues struct {
	AcceptOrganizationInvitationResponse_FieldTerminalPath
	values interface{}
}

var _ AcceptOrganizationInvitationResponse_FieldPathArrayOfValues = (*AcceptOrganizationInvitationResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AcceptOrganizationInvitationResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	}
	return
}

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

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

type DeclineOrganizationInvitationRequest_FieldPathSelector int32

const (
	DeclineOrganizationInvitationRequest_FieldPathSelectorName   DeclineOrganizationInvitationRequest_FieldPathSelector = 0
	DeclineOrganizationInvitationRequest_FieldPathSelectorFilter DeclineOrganizationInvitationRequest_FieldPathSelector = 1
)

func (s DeclineOrganizationInvitationRequest_FieldPathSelector) String() string {
	switch s {
	case DeclineOrganizationInvitationRequest_FieldPathSelectorName:
		return "name"
	case DeclineOrganizationInvitationRequest_FieldPathSelectorFilter:
		return "filter"
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationRequest: %d", s))
	}
}

func BuildDeclineOrganizationInvitationRequest_FieldPath(fp gotenobject.RawFieldPath) (DeclineOrganizationInvitationRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object DeclineOrganizationInvitationRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &DeclineOrganizationInvitationRequest_FieldTerminalPath{selector: DeclineOrganizationInvitationRequest_FieldPathSelectorName}, nil
		case "filter":
			return &DeclineOrganizationInvitationRequest_FieldTerminalPath{selector: DeclineOrganizationInvitationRequest_FieldPathSelectorFilter}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object DeclineOrganizationInvitationRequest", fp)
}

func ParseDeclineOrganizationInvitationRequest_FieldPath(rawField string) (DeclineOrganizationInvitationRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeclineOrganizationInvitationRequest_FieldPath(fp)
}

func MustParseDeclineOrganizationInvitationRequest_FieldPath(rawField string) DeclineOrganizationInvitationRequest_FieldPath {
	fp, err := ParseDeclineOrganizationInvitationRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeclineOrganizationInvitationRequest_FieldTerminalPath struct {
	selector DeclineOrganizationInvitationRequest_FieldPathSelector
}

var _ DeclineOrganizationInvitationRequest_FieldPath = (*DeclineOrganizationInvitationRequest_FieldTerminalPath)(nil)

func (fp *DeclineOrganizationInvitationRequest_FieldTerminalPath) Selector() DeclineOrganizationInvitationRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *DeclineOrganizationInvitationRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeclineOrganizationInvitationRequest_FieldPathSelectorName:
		return (*organization_invitation.Reference)(nil)
	case DeclineOrganizationInvitationRequest_FieldPathSelectorFilter:
		return (*project_invitation.Filter)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationRequest: %d", fp.selector))
	}
}

func (fp *DeclineOrganizationInvitationRequest_FieldTerminalPath) ClearValue(item *DeclineOrganizationInvitationRequest) {
	if item != nil {
		switch fp.selector {
		case DeclineOrganizationInvitationRequest_FieldPathSelectorName:
			item.Name = nil
		case DeclineOrganizationInvitationRequest_FieldPathSelectorFilter:
			item.Filter = nil
		default:
			panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationRequest: %d", fp.selector))
		}
	}
}

func (fp *DeclineOrganizationInvitationRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*DeclineOrganizationInvitationRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *DeclineOrganizationInvitationRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == DeclineOrganizationInvitationRequest_FieldPathSelectorName ||
		fp.selector == DeclineOrganizationInvitationRequest_FieldPathSelectorFilter
}

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

func (fp *DeclineOrganizationInvitationRequest_FieldTerminalPath) WithIValue(value interface{}) DeclineOrganizationInvitationRequest_FieldPathValue {
	switch fp.selector {
	case DeclineOrganizationInvitationRequest_FieldPathSelectorName:
		return &DeclineOrganizationInvitationRequest_FieldTerminalPathValue{DeclineOrganizationInvitationRequest_FieldTerminalPath: *fp, value: value.(*organization_invitation.Reference)}
	case DeclineOrganizationInvitationRequest_FieldPathSelectorFilter:
		return &DeclineOrganizationInvitationRequest_FieldTerminalPathValue{DeclineOrganizationInvitationRequest_FieldTerminalPath: *fp, value: value.(*project_invitation.Filter)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationRequest: %d", fp.selector))
	}
}

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

func (fp *DeclineOrganizationInvitationRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeclineOrganizationInvitationRequest_FieldPathArrayOfValues {
	fpaov := &DeclineOrganizationInvitationRequest_FieldTerminalPathArrayOfValues{DeclineOrganizationInvitationRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeclineOrganizationInvitationRequest_FieldPathSelectorName:
		return &DeclineOrganizationInvitationRequest_FieldTerminalPathArrayOfValues{DeclineOrganizationInvitationRequest_FieldTerminalPath: *fp, values: values.([]*organization_invitation.Reference)}
	case DeclineOrganizationInvitationRequest_FieldPathSelectorFilter:
		return &DeclineOrganizationInvitationRequest_FieldTerminalPathArrayOfValues{DeclineOrganizationInvitationRequest_FieldTerminalPath: *fp, values: values.([]*project_invitation.Filter)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseDeclineOrganizationInvitationRequest_FieldPathValue(pathStr, valueStr string) DeclineOrganizationInvitationRequest_FieldPathValue {
	fpv, err := ParseDeclineOrganizationInvitationRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeclineOrganizationInvitationRequest_FieldTerminalPathValue struct {
	DeclineOrganizationInvitationRequest_FieldTerminalPath
	value interface{}
}

var _ DeclineOrganizationInvitationRequest_FieldPathValue = (*DeclineOrganizationInvitationRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'DeclineOrganizationInvitationRequest' as interface{}
func (fpv *DeclineOrganizationInvitationRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeclineOrganizationInvitationRequest_FieldTerminalPathValue) AsNameValue() (*organization_invitation.Reference, bool) {
	res, ok := fpv.value.(*organization_invitation.Reference)
	return res, ok
}
func (fpv *DeclineOrganizationInvitationRequest_FieldTerminalPathValue) AsFilterValue() (*project_invitation.Filter, bool) {
	res, ok := fpv.value.(*project_invitation.Filter)
	return res, ok
}

// SetTo stores value for selected field for object DeclineOrganizationInvitationRequest
func (fpv *DeclineOrganizationInvitationRequest_FieldTerminalPathValue) SetTo(target **DeclineOrganizationInvitationRequest) {
	if *target == nil {
		*target = new(DeclineOrganizationInvitationRequest)
	}
	switch fpv.selector {
	case DeclineOrganizationInvitationRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*organization_invitation.Reference)
	case DeclineOrganizationInvitationRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*project_invitation.Filter)
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationRequest: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseDeclineOrganizationInvitationRequest_FieldPathArrayItemValue(pathStr, valueStr string) DeclineOrganizationInvitationRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseDeclineOrganizationInvitationRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeclineOrganizationInvitationRequest_FieldTerminalPathArrayItemValue struct {
	DeclineOrganizationInvitationRequest_FieldTerminalPath
	value interface{}
}

var _ DeclineOrganizationInvitationRequest_FieldPathArrayItemValue = (*DeclineOrganizationInvitationRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeclineOrganizationInvitationRequest_FieldTerminalPathArrayItemValue) GetSingle(source *DeclineOrganizationInvitationRequest) (interface{}, bool) {
	return nil, false
}

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

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

// DeclineOrganizationInvitationRequest_FieldPathArrayOfValues allows storing slice of values for DeclineOrganizationInvitationRequest fields according to their type
type DeclineOrganizationInvitationRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeclineOrganizationInvitationRequest_FieldPath
}

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

func MustParseDeclineOrganizationInvitationRequest_FieldPathArrayOfValues(pathStr, valuesStr string) DeclineOrganizationInvitationRequest_FieldPathArrayOfValues {
	fpaov, err := ParseDeclineOrganizationInvitationRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeclineOrganizationInvitationRequest_FieldTerminalPathArrayOfValues struct {
	DeclineOrganizationInvitationRequest_FieldTerminalPath
	values interface{}
}

var _ DeclineOrganizationInvitationRequest_FieldPathArrayOfValues = (*DeclineOrganizationInvitationRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeclineOrganizationInvitationRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeclineOrganizationInvitationRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*organization_invitation.Reference) {
			values = append(values, v)
		}
	case DeclineOrganizationInvitationRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*project_invitation.Filter) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeclineOrganizationInvitationRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*organization_invitation.Reference, bool) {
	res, ok := fpaov.values.([]*organization_invitation.Reference)
	return res, ok
}
func (fpaov *DeclineOrganizationInvitationRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*project_invitation.Filter, bool) {
	res, ok := fpaov.values.([]*project_invitation.Filter)
	return res, ok
}

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

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

type DeclineOrganizationInvitationResponse_FieldPathSelector int32

func (s DeclineOrganizationInvitationResponse_FieldPathSelector) String() string {
	switch s {
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationResponse: %d", s))
	}
}

func BuildDeclineOrganizationInvitationResponse_FieldPath(fp gotenobject.RawFieldPath) (DeclineOrganizationInvitationResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object DeclineOrganizationInvitationResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object DeclineOrganizationInvitationResponse", fp)
}

func ParseDeclineOrganizationInvitationResponse_FieldPath(rawField string) (DeclineOrganizationInvitationResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeclineOrganizationInvitationResponse_FieldPath(fp)
}

func MustParseDeclineOrganizationInvitationResponse_FieldPath(rawField string) DeclineOrganizationInvitationResponse_FieldPath {
	fp, err := ParseDeclineOrganizationInvitationResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeclineOrganizationInvitationResponse_FieldTerminalPath struct {
	selector DeclineOrganizationInvitationResponse_FieldPathSelector
}

var _ DeclineOrganizationInvitationResponse_FieldPath = (*DeclineOrganizationInvitationResponse_FieldTerminalPath)(nil)

func (fp *DeclineOrganizationInvitationResponse_FieldTerminalPath) Selector() DeclineOrganizationInvitationResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source DeclineOrganizationInvitationResponse
func (fp *DeclineOrganizationInvitationResponse_FieldTerminalPath) GetSingle(source *DeclineOrganizationInvitationResponse) (interface{}, bool) {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *DeclineOrganizationInvitationResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationResponse: %d", fp.selector))
	}
}

func (fp *DeclineOrganizationInvitationResponse_FieldTerminalPath) ClearValue(item *DeclineOrganizationInvitationResponse) {
	if item != nil {
		switch fp.selector {
		default:
			panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationResponse: %d", fp.selector))
		}
	}
}

func (fp *DeclineOrganizationInvitationResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*DeclineOrganizationInvitationResponse))
}

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

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

func (fp *DeclineOrganizationInvitationResponse_FieldTerminalPath) WithIValue(value interface{}) DeclineOrganizationInvitationResponse_FieldPathValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationResponse: %d", fp.selector))
	}
}

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

func (fp *DeclineOrganizationInvitationResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeclineOrganizationInvitationResponse_FieldPathArrayOfValues {
	fpaov := &DeclineOrganizationInvitationResponse_FieldTerminalPathArrayOfValues{DeclineOrganizationInvitationResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseDeclineOrganizationInvitationResponse_FieldPathValue(pathStr, valueStr string) DeclineOrganizationInvitationResponse_FieldPathValue {
	fpv, err := ParseDeclineOrganizationInvitationResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeclineOrganizationInvitationResponse_FieldTerminalPathValue struct {
	DeclineOrganizationInvitationResponse_FieldTerminalPath
	value interface{}
}

var _ DeclineOrganizationInvitationResponse_FieldPathValue = (*DeclineOrganizationInvitationResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'DeclineOrganizationInvitationResponse' as interface{}
func (fpv *DeclineOrganizationInvitationResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}

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

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

// CompareWith compares value in the 'DeclineOrganizationInvitationResponse_FieldTerminalPathValue' with the value under path in 'DeclineOrganizationInvitationResponse'.
func (fpv *DeclineOrganizationInvitationResponse_FieldTerminalPathValue) CompareWith(source *DeclineOrganizationInvitationResponse) (int, bool) {
	switch fpv.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for DeclineOrganizationInvitationResponse: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeclineOrganizationInvitationResponse_FieldPathArrayItemValue(pathStr, valueStr string) DeclineOrganizationInvitationResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseDeclineOrganizationInvitationResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeclineOrganizationInvitationResponse_FieldTerminalPathArrayItemValue struct {
	DeclineOrganizationInvitationResponse_FieldTerminalPath
	value interface{}
}

var _ DeclineOrganizationInvitationResponse_FieldPathArrayItemValue = (*DeclineOrganizationInvitationResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeclineOrganizationInvitationResponse_FieldTerminalPathArrayItemValue) GetSingle(source *DeclineOrganizationInvitationResponse) (interface{}, bool) {
	return nil, false
}

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

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

// DeclineOrganizationInvitationResponse_FieldPathArrayOfValues allows storing slice of values for DeclineOrganizationInvitationResponse fields according to their type
type DeclineOrganizationInvitationResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeclineOrganizationInvitationResponse_FieldPath
}

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

func MustParseDeclineOrganizationInvitationResponse_FieldPathArrayOfValues(pathStr, valuesStr string) DeclineOrganizationInvitationResponse_FieldPathArrayOfValues {
	fpaov, err := ParseDeclineOrganizationInvitationResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeclineOrganizationInvitationResponse_FieldTerminalPathArrayOfValues struct {
	DeclineOrganizationInvitationResponse_FieldTerminalPath
	values interface{}
}

var _ DeclineOrganizationInvitationResponse_FieldPathArrayOfValues = (*DeclineOrganizationInvitationResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeclineOrganizationInvitationResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	}
	return
}

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

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

type ListMyOrganizationInvitationsRequest_FieldPathSelector int32

const (
	ListMyOrganizationInvitationsRequest_FieldPathSelectorParent ListMyOrganizationInvitationsRequest_FieldPathSelector = 0
	ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter ListMyOrganizationInvitationsRequest_FieldPathSelector = 1
)

func (s ListMyOrganizationInvitationsRequest_FieldPathSelector) String() string {
	switch s {
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorParent:
		return "parent"
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter:
		return "filter"
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsRequest: %d", s))
	}
}

func BuildListMyOrganizationInvitationsRequest_FieldPath(fp gotenobject.RawFieldPath) (ListMyOrganizationInvitationsRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListMyOrganizationInvitationsRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &ListMyOrganizationInvitationsRequest_FieldTerminalPath{selector: ListMyOrganizationInvitationsRequest_FieldPathSelectorParent}, nil
		case "filter":
			return &ListMyOrganizationInvitationsRequest_FieldTerminalPath{selector: ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListMyOrganizationInvitationsRequest", fp)
}

func ParseListMyOrganizationInvitationsRequest_FieldPath(rawField string) (ListMyOrganizationInvitationsRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListMyOrganizationInvitationsRequest_FieldPath(fp)
}

func MustParseListMyOrganizationInvitationsRequest_FieldPath(rawField string) ListMyOrganizationInvitationsRequest_FieldPath {
	fp, err := ParseListMyOrganizationInvitationsRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListMyOrganizationInvitationsRequest_FieldTerminalPath struct {
	selector ListMyOrganizationInvitationsRequest_FieldPathSelector
}

var _ ListMyOrganizationInvitationsRequest_FieldPath = (*ListMyOrganizationInvitationsRequest_FieldTerminalPath)(nil)

func (fp *ListMyOrganizationInvitationsRequest_FieldTerminalPath) Selector() ListMyOrganizationInvitationsRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *ListMyOrganizationInvitationsRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorParent:
		return (*organization_invitation.ParentReference)(nil)
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter:
		return (*organization_invitation.Filter)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsRequest: %d", fp.selector))
	}
}

func (fp *ListMyOrganizationInvitationsRequest_FieldTerminalPath) ClearValue(item *ListMyOrganizationInvitationsRequest) {
	if item != nil {
		switch fp.selector {
		case ListMyOrganizationInvitationsRequest_FieldPathSelectorParent:
			item.Parent = nil
		case ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter:
			item.Filter = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsRequest: %d", fp.selector))
		}
	}
}

func (fp *ListMyOrganizationInvitationsRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListMyOrganizationInvitationsRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListMyOrganizationInvitationsRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListMyOrganizationInvitationsRequest_FieldPathSelectorParent ||
		fp.selector == ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter
}

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

func (fp *ListMyOrganizationInvitationsRequest_FieldTerminalPath) WithIValue(value interface{}) ListMyOrganizationInvitationsRequest_FieldPathValue {
	switch fp.selector {
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorParent:
		return &ListMyOrganizationInvitationsRequest_FieldTerminalPathValue{ListMyOrganizationInvitationsRequest_FieldTerminalPath: *fp, value: value.(*organization_invitation.ParentReference)}
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter:
		return &ListMyOrganizationInvitationsRequest_FieldTerminalPathValue{ListMyOrganizationInvitationsRequest_FieldTerminalPath: *fp, value: value.(*organization_invitation.Filter)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsRequest: %d", fp.selector))
	}
}

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

func (fp *ListMyOrganizationInvitationsRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListMyOrganizationInvitationsRequest_FieldPathArrayOfValues {
	fpaov := &ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayOfValues{ListMyOrganizationInvitationsRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorParent:
		return &ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayOfValues{ListMyOrganizationInvitationsRequest_FieldTerminalPath: *fp, values: values.([]*organization_invitation.ParentReference)}
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter:
		return &ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayOfValues{ListMyOrganizationInvitationsRequest_FieldTerminalPath: *fp, values: values.([]*organization_invitation.Filter)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseListMyOrganizationInvitationsRequest_FieldPathValue(pathStr, valueStr string) ListMyOrganizationInvitationsRequest_FieldPathValue {
	fpv, err := ParseListMyOrganizationInvitationsRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListMyOrganizationInvitationsRequest_FieldTerminalPathValue struct {
	ListMyOrganizationInvitationsRequest_FieldTerminalPath
	value interface{}
}

var _ ListMyOrganizationInvitationsRequest_FieldPathValue = (*ListMyOrganizationInvitationsRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListMyOrganizationInvitationsRequest' as interface{}
func (fpv *ListMyOrganizationInvitationsRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListMyOrganizationInvitationsRequest_FieldTerminalPathValue) AsParentValue() (*organization_invitation.ParentReference, bool) {
	res, ok := fpv.value.(*organization_invitation.ParentReference)
	return res, ok
}
func (fpv *ListMyOrganizationInvitationsRequest_FieldTerminalPathValue) AsFilterValue() (*organization_invitation.Filter, bool) {
	res, ok := fpv.value.(*organization_invitation.Filter)
	return res, ok
}

// SetTo stores value for selected field for object ListMyOrganizationInvitationsRequest
func (fpv *ListMyOrganizationInvitationsRequest_FieldTerminalPathValue) SetTo(target **ListMyOrganizationInvitationsRequest) {
	if *target == nil {
		*target = new(ListMyOrganizationInvitationsRequest)
	}
	switch fpv.selector {
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*organization_invitation.ParentReference)
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*organization_invitation.Filter)
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListMyOrganizationInvitationsRequest_FieldTerminalPathValue' with the value under path in 'ListMyOrganizationInvitationsRequest'.
func (fpv *ListMyOrganizationInvitationsRequest_FieldTerminalPathValue) CompareWith(source *ListMyOrganizationInvitationsRequest) (int, bool) {
	switch fpv.selector {
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*organization_invitation.ParentReference)
		rightValue := source.GetParent()
		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 ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseListMyOrganizationInvitationsRequest_FieldPathArrayItemValue(pathStr, valueStr string) ListMyOrganizationInvitationsRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseListMyOrganizationInvitationsRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayItemValue struct {
	ListMyOrganizationInvitationsRequest_FieldTerminalPath
	value interface{}
}

var _ ListMyOrganizationInvitationsRequest_FieldPathArrayItemValue = (*ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ListMyOrganizationInvitationsRequest) (interface{}, bool) {
	return nil, false
}

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

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

// ListMyOrganizationInvitationsRequest_FieldPathArrayOfValues allows storing slice of values for ListMyOrganizationInvitationsRequest fields according to their type
type ListMyOrganizationInvitationsRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListMyOrganizationInvitationsRequest_FieldPath
}

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

func MustParseListMyOrganizationInvitationsRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ListMyOrganizationInvitationsRequest_FieldPathArrayOfValues {
	fpaov, err := ParseListMyOrganizationInvitationsRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayOfValues struct {
	ListMyOrganizationInvitationsRequest_FieldTerminalPath
	values interface{}
}

var _ ListMyOrganizationInvitationsRequest_FieldPathArrayOfValues = (*ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*organization_invitation.ParentReference) {
			values = append(values, v)
		}
	case ListMyOrganizationInvitationsRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*organization_invitation.Filter) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*organization_invitation.ParentReference, bool) {
	res, ok := fpaov.values.([]*organization_invitation.ParentReference)
	return res, ok
}
func (fpaov *ListMyOrganizationInvitationsRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*organization_invitation.Filter, bool) {
	res, ok := fpaov.values.([]*organization_invitation.Filter)
	return res, ok
}

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

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

type ListMyOrganizationInvitationsResponse_FieldPathSelector int32

const (
	ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations ListMyOrganizationInvitationsResponse_FieldPathSelector = 0
)

func (s ListMyOrganizationInvitationsResponse_FieldPathSelector) String() string {
	switch s {
	case ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations:
		return "organization_invitations"
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsResponse: %d", s))
	}
}

func BuildListMyOrganizationInvitationsResponse_FieldPath(fp gotenobject.RawFieldPath) (ListMyOrganizationInvitationsResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListMyOrganizationInvitationsResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "organization_invitations", "organizationInvitations", "organization-invitations":
			return &ListMyOrganizationInvitationsResponse_FieldTerminalPath{selector: ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations}, nil
		}
	} else {
		switch fp[0] {
		case "organization_invitations", "organizationInvitations", "organization-invitations":
			if subpath, err := organization_invitation.BuildOrganizationInvitation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListMyOrganizationInvitationsResponse_FieldSubPath{selector: ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListMyOrganizationInvitationsResponse", fp)
}

func ParseListMyOrganizationInvitationsResponse_FieldPath(rawField string) (ListMyOrganizationInvitationsResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListMyOrganizationInvitationsResponse_FieldPath(fp)
}

func MustParseListMyOrganizationInvitationsResponse_FieldPath(rawField string) ListMyOrganizationInvitationsResponse_FieldPath {
	fp, err := ParseListMyOrganizationInvitationsResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListMyOrganizationInvitationsResponse_FieldTerminalPath struct {
	selector ListMyOrganizationInvitationsResponse_FieldPathSelector
}

var _ ListMyOrganizationInvitationsResponse_FieldPath = (*ListMyOrganizationInvitationsResponse_FieldTerminalPath)(nil)

func (fp *ListMyOrganizationInvitationsResponse_FieldTerminalPath) Selector() ListMyOrganizationInvitationsResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *ListMyOrganizationInvitationsResponse_FieldTerminalPath) ClearValue(item *ListMyOrganizationInvitationsResponse) {
	if item != nil {
		switch fp.selector {
		case ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations:
			item.OrganizationInvitations = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsResponse: %d", fp.selector))
		}
	}
}

func (fp *ListMyOrganizationInvitationsResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListMyOrganizationInvitationsResponse))
}

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

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

func (fp *ListMyOrganizationInvitationsResponse_FieldTerminalPath) WithIValue(value interface{}) ListMyOrganizationInvitationsResponse_FieldPathValue {
	switch fp.selector {
	case ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations:
		return &ListMyOrganizationInvitationsResponse_FieldTerminalPathValue{ListMyOrganizationInvitationsResponse_FieldTerminalPath: *fp, value: value.([]*organization_invitation.OrganizationInvitation)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsResponse: %d", fp.selector))
	}
}

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

func (fp *ListMyOrganizationInvitationsResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListMyOrganizationInvitationsResponse_FieldPathArrayOfValues {
	fpaov := &ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayOfValues{ListMyOrganizationInvitationsResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations:
		return &ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayOfValues{ListMyOrganizationInvitationsResponse_FieldTerminalPath: *fp, values: values.([][]*organization_invitation.OrganizationInvitation)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *ListMyOrganizationInvitationsResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListMyOrganizationInvitationsResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations:
		return &ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayItemValue{ListMyOrganizationInvitationsResponse_FieldTerminalPath: *fp, value: value.(*organization_invitation.OrganizationInvitation)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsResponse: %d", fp.selector))
	}
}

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

type ListMyOrganizationInvitationsResponse_FieldSubPath struct {
	selector ListMyOrganizationInvitationsResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListMyOrganizationInvitationsResponse_FieldPath = (*ListMyOrganizationInvitationsResponse_FieldSubPath)(nil)

func (fps *ListMyOrganizationInvitationsResponse_FieldSubPath) Selector() ListMyOrganizationInvitationsResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ListMyOrganizationInvitationsResponse_FieldSubPath) AsOrganizationInvitationsSubPath() (organization_invitation.OrganizationInvitation_FieldPath, bool) {
	res, ok := fps.subPath.(organization_invitation.OrganizationInvitation_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *ListMyOrganizationInvitationsResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListMyOrganizationInvitationsResponse))
}

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

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

func (fps *ListMyOrganizationInvitationsResponse_FieldSubPath) WithIValue(value interface{}) ListMyOrganizationInvitationsResponse_FieldPathValue {
	return &ListMyOrganizationInvitationsResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ListMyOrganizationInvitationsResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ListMyOrganizationInvitationsResponse_FieldPathArrayOfValues {
	return &ListMyOrganizationInvitationsResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ListMyOrganizationInvitationsResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ListMyOrganizationInvitationsResponse_FieldPathArrayItemValue {
	return &ListMyOrganizationInvitationsResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseListMyOrganizationInvitationsResponse_FieldPathValue(pathStr, valueStr string) ListMyOrganizationInvitationsResponse_FieldPathValue {
	fpv, err := ParseListMyOrganizationInvitationsResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListMyOrganizationInvitationsResponse_FieldTerminalPathValue struct {
	ListMyOrganizationInvitationsResponse_FieldTerminalPath
	value interface{}
}

var _ ListMyOrganizationInvitationsResponse_FieldPathValue = (*ListMyOrganizationInvitationsResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListMyOrganizationInvitationsResponse' as interface{}
func (fpv *ListMyOrganizationInvitationsResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListMyOrganizationInvitationsResponse_FieldTerminalPathValue) AsOrganizationInvitationsValue() ([]*organization_invitation.OrganizationInvitation, bool) {
	res, ok := fpv.value.([]*organization_invitation.OrganizationInvitation)
	return res, ok
}

// SetTo stores value for selected field for object ListMyOrganizationInvitationsResponse
func (fpv *ListMyOrganizationInvitationsResponse_FieldTerminalPathValue) SetTo(target **ListMyOrganizationInvitationsResponse) {
	if *target == nil {
		*target = new(ListMyOrganizationInvitationsResponse)
	}
	switch fpv.selector {
	case ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations:
		(*target).OrganizationInvitations = fpv.value.([]*organization_invitation.OrganizationInvitation)
	default:
		panic(fmt.Sprintf("Invalid selector for ListMyOrganizationInvitationsResponse: %d", fpv.selector))
	}
}

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

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

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

type ListMyOrganizationInvitationsResponse_FieldSubPathValue struct {
	ListMyOrganizationInvitationsResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListMyOrganizationInvitationsResponse_FieldPathValue = (*ListMyOrganizationInvitationsResponse_FieldSubPathValue)(nil)

func (fpvs *ListMyOrganizationInvitationsResponse_FieldSubPathValue) AsOrganizationInvitationsPathValue() (organization_invitation.OrganizationInvitation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(organization_invitation.OrganizationInvitation_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseListMyOrganizationInvitationsResponse_FieldPathArrayItemValue(pathStr, valueStr string) ListMyOrganizationInvitationsResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseListMyOrganizationInvitationsResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayItemValue struct {
	ListMyOrganizationInvitationsResponse_FieldTerminalPath
	value interface{}
}

var _ ListMyOrganizationInvitationsResponse_FieldPathArrayItemValue = (*ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListMyOrganizationInvitationsResponse as interface{}
func (fpaiv *ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayItemValue) AsOrganizationInvitationsItemValue() (*organization_invitation.OrganizationInvitation, bool) {
	res, ok := fpaiv.value.(*organization_invitation.OrganizationInvitation)
	return res, ok
}

func (fpaiv *ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ListMyOrganizationInvitationsResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ListMyOrganizationInvitationsResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListMyOrganizationInvitationsResponse_FieldSubPathArrayItemValue) AsOrganizationInvitationsPathItemValue() (organization_invitation.OrganizationInvitation_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(organization_invitation.OrganizationInvitation_FieldPathArrayItemValue)
	return res, ok
}

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

// ListMyOrganizationInvitationsResponse_FieldPathArrayOfValues allows storing slice of values for ListMyOrganizationInvitationsResponse fields according to their type
type ListMyOrganizationInvitationsResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListMyOrganizationInvitationsResponse_FieldPath
}

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

func MustParseListMyOrganizationInvitationsResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ListMyOrganizationInvitationsResponse_FieldPathArrayOfValues {
	fpaov, err := ParseListMyOrganizationInvitationsResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayOfValues struct {
	ListMyOrganizationInvitationsResponse_FieldTerminalPath
	values interface{}
}

var _ ListMyOrganizationInvitationsResponse_FieldPathArrayOfValues = (*ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListMyOrganizationInvitationsResponse_FieldPathSelectorOrganizationInvitations:
		for _, v := range fpaov.values.([][]*organization_invitation.OrganizationInvitation) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListMyOrganizationInvitationsResponse_FieldTerminalPathArrayOfValues) AsOrganizationInvitationsArrayOfValues() ([][]*organization_invitation.OrganizationInvitation, bool) {
	res, ok := fpaov.values.([][]*organization_invitation.OrganizationInvitation)
	return res, ok
}

type ListMyOrganizationInvitationsResponse_FieldSubPathArrayOfValues struct {
	ListMyOrganizationInvitationsResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListMyOrganizationInvitationsResponse_FieldPathArrayOfValues = (*ListMyOrganizationInvitationsResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListMyOrganizationInvitationsResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListMyOrganizationInvitationsResponse_FieldSubPathArrayOfValues) AsOrganizationInvitationsPathArrayOfValues() (organization_invitation.OrganizationInvitation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(organization_invitation.OrganizationInvitation_FieldPathArrayOfValues)
	return res, ok
}