notification.pb.fieldpath.go

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

package notification

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

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

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

// proto imports
import (
	ntt_meta "github.com/cloudwan/edgelq-sdk/common/types/meta"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/common/v3"
	alert "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alert"
	alerting_condition "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alerting_condition"
	alerting_policy "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alerting_policy"
	notification_channel "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/notification_channel"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/project"
)

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

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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &ntt_meta.Meta{}
	_ = &alert.Alert{}
	_ = &alerting_condition.AlertingCondition{}
	_ = &alerting_policy.AlertingPolicy{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &notification_channel.NotificationChannel{}
	_ = &project.Project{}
)

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

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

type Notification_FieldPathSelector int32

const (
	Notification_FieldPathSelectorName           Notification_FieldPathSelector = 0
	Notification_FieldPathSelectorMetadata       Notification_FieldPathSelector = 1
	Notification_FieldPathSelectorAlertingPolicy Notification_FieldPathSelector = 2
	Notification_FieldPathSelectorAlerts         Notification_FieldPathSelector = 3
	Notification_FieldPathSelectorState          Notification_FieldPathSelector = 4
)

func (s Notification_FieldPathSelector) String() string {
	switch s {
	case Notification_FieldPathSelectorName:
		return "name"
	case Notification_FieldPathSelectorMetadata:
		return "metadata"
	case Notification_FieldPathSelectorAlertingPolicy:
		return "alerting_policy"
	case Notification_FieldPathSelectorAlerts:
		return "alerts"
	case Notification_FieldPathSelectorState:
		return "state"
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", s))
	}
}

func BuildNotification_FieldPath(fp gotenobject.RawFieldPath) (Notification_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Notification")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &Notification_FieldTerminalPath{selector: Notification_FieldPathSelectorName}, nil
		case "metadata":
			return &Notification_FieldTerminalPath{selector: Notification_FieldPathSelectorMetadata}, nil
		case "alerting_policy", "alertingPolicy", "alerting-policy":
			return &Notification_FieldTerminalPath{selector: Notification_FieldPathSelectorAlertingPolicy}, nil
		case "alerts":
			return &Notification_FieldTerminalPath{selector: Notification_FieldPathSelectorAlerts}, nil
		case "state":
			return &Notification_FieldTerminalPath{selector: Notification_FieldPathSelectorState}, nil
		}
	} else {
		switch fp[0] {
		case "metadata":
			if subpath, err := ntt_meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Notification_FieldSubPath{selector: Notification_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		case "state":
			if subpath, err := BuildNotificationState_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Notification_FieldSubPath{selector: Notification_FieldPathSelectorState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Notification", fp)
}

func ParseNotification_FieldPath(rawField string) (Notification_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotification_FieldPath(fp)
}

func MustParseNotification_FieldPath(rawField string) Notification_FieldPath {
	fp, err := ParseNotification_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type Notification_FieldTerminalPath struct {
	selector Notification_FieldPathSelector
}

var _ Notification_FieldPath = (*Notification_FieldTerminalPath)(nil)

func (fp *Notification_FieldTerminalPath) Selector() Notification_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Notification
func (fp *Notification_FieldTerminalPath) Get(source *Notification) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case Notification_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case Notification_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		case Notification_FieldPathSelectorAlertingPolicy:
			if source.AlertingPolicy != nil {
				values = append(values, source.AlertingPolicy)
			}
		case Notification_FieldPathSelectorAlerts:
			for _, value := range source.GetAlerts() {
				values = append(values, value)
			}
		case Notification_FieldPathSelectorState:
			if source.State != nil {
				values = append(values, source.State)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Notification: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Notification
func (fp *Notification_FieldTerminalPath) GetSingle(source *Notification) (interface{}, bool) {
	switch fp.selector {
	case Notification_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case Notification_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		return res, res != nil
	case Notification_FieldPathSelectorAlertingPolicy:
		res := source.GetAlertingPolicy()
		return res, res != nil
	case Notification_FieldPathSelectorAlerts:
		res := source.GetAlerts()
		return res, res != nil
	case Notification_FieldPathSelectorState:
		res := source.GetState()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *Notification_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case Notification_FieldPathSelectorName:
		return (*Name)(nil)
	case Notification_FieldPathSelectorMetadata:
		return (*ntt_meta.Meta)(nil)
	case Notification_FieldPathSelectorAlertingPolicy:
		return (*alerting_policy.Name)(nil)
	case Notification_FieldPathSelectorAlerts:
		return ([]*alert.Name)(nil)
	case Notification_FieldPathSelectorState:
		return (*Notification_State)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fp.selector))
	}
}

func (fp *Notification_FieldTerminalPath) ClearValue(item *Notification) {
	if item != nil {
		switch fp.selector {
		case Notification_FieldPathSelectorName:
			item.Name = nil
		case Notification_FieldPathSelectorMetadata:
			item.Metadata = nil
		case Notification_FieldPathSelectorAlertingPolicy:
			item.AlertingPolicy = nil
		case Notification_FieldPathSelectorAlerts:
			item.Alerts = nil
		case Notification_FieldPathSelectorState:
			item.State = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Notification: %d", fp.selector))
		}
	}
}

func (fp *Notification_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Notification))
}

// IsLeaf - whether field path is holds simple value
func (fp *Notification_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == Notification_FieldPathSelectorName ||
		fp.selector == Notification_FieldPathSelectorAlertingPolicy ||
		fp.selector == Notification_FieldPathSelectorAlerts
}

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

func (fp *Notification_FieldTerminalPath) WithIValue(value interface{}) Notification_FieldPathValue {
	switch fp.selector {
	case Notification_FieldPathSelectorName:
		return &Notification_FieldTerminalPathValue{Notification_FieldTerminalPath: *fp, value: value.(*Name)}
	case Notification_FieldPathSelectorMetadata:
		return &Notification_FieldTerminalPathValue{Notification_FieldTerminalPath: *fp, value: value.(*ntt_meta.Meta)}
	case Notification_FieldPathSelectorAlertingPolicy:
		return &Notification_FieldTerminalPathValue{Notification_FieldTerminalPath: *fp, value: value.(*alerting_policy.Name)}
	case Notification_FieldPathSelectorAlerts:
		return &Notification_FieldTerminalPathValue{Notification_FieldTerminalPath: *fp, value: value.([]*alert.Name)}
	case Notification_FieldPathSelectorState:
		return &Notification_FieldTerminalPathValue{Notification_FieldTerminalPath: *fp, value: value.(*Notification_State)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fp.selector))
	}
}

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

func (fp *Notification_FieldTerminalPath) WithIArrayOfValues(values interface{}) Notification_FieldPathArrayOfValues {
	fpaov := &Notification_FieldTerminalPathArrayOfValues{Notification_FieldTerminalPath: *fp}
	switch fp.selector {
	case Notification_FieldPathSelectorName:
		return &Notification_FieldTerminalPathArrayOfValues{Notification_FieldTerminalPath: *fp, values: values.([]*Name)}
	case Notification_FieldPathSelectorMetadata:
		return &Notification_FieldTerminalPathArrayOfValues{Notification_FieldTerminalPath: *fp, values: values.([]*ntt_meta.Meta)}
	case Notification_FieldPathSelectorAlertingPolicy:
		return &Notification_FieldTerminalPathArrayOfValues{Notification_FieldTerminalPath: *fp, values: values.([]*alerting_policy.Name)}
	case Notification_FieldPathSelectorAlerts:
		return &Notification_FieldTerminalPathArrayOfValues{Notification_FieldTerminalPath: *fp, values: values.([][]*alert.Name)}
	case Notification_FieldPathSelectorState:
		return &Notification_FieldTerminalPathArrayOfValues{Notification_FieldTerminalPath: *fp, values: values.([]*Notification_State)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *Notification_FieldTerminalPath) WithIArrayItemValue(value interface{}) Notification_FieldPathArrayItemValue {
	switch fp.selector {
	case Notification_FieldPathSelectorAlerts:
		return &Notification_FieldTerminalPathArrayItemValue{Notification_FieldTerminalPath: *fp, value: value.(*alert.Name)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fp.selector))
	}
}

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

type Notification_FieldSubPath struct {
	selector Notification_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ Notification_FieldPath = (*Notification_FieldSubPath)(nil)

func (fps *Notification_FieldSubPath) Selector() Notification_FieldPathSelector {
	return fps.selector
}
func (fps *Notification_FieldSubPath) AsMetadataSubPath() (ntt_meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(ntt_meta.Meta_FieldPath)
	return res, ok
}
func (fps *Notification_FieldSubPath) AsStateSubPath() (NotificationState_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationState_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *Notification_FieldSubPath) ClearValue(item *Notification) {
	if item != nil {
		switch fps.selector {
		case Notification_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		case Notification_FieldPathSelectorState:
			fps.subPath.ClearValueRaw(item.State)
		default:
			panic(fmt.Sprintf("Invalid selector for Notification: %d", fps.selector))
		}
	}
}

func (fps *Notification_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Notification))
}

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

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

func (fps *Notification_FieldSubPath) WithIValue(value interface{}) Notification_FieldPathValue {
	return &Notification_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *Notification_FieldSubPath) WithIArrayOfValues(values interface{}) Notification_FieldPathArrayOfValues {
	return &Notification_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *Notification_FieldSubPath) WithIArrayItemValue(value interface{}) Notification_FieldPathArrayItemValue {
	return &Notification_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseNotification_FieldPathValue(pathStr, valueStr string) Notification_FieldPathValue {
	fpv, err := ParseNotification_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type Notification_FieldTerminalPathValue struct {
	Notification_FieldTerminalPath
	value interface{}
}

var _ Notification_FieldPathValue = (*Notification_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Notification' as interface{}
func (fpv *Notification_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *Notification_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *Notification_FieldTerminalPathValue) AsMetadataValue() (*ntt_meta.Meta, bool) {
	res, ok := fpv.value.(*ntt_meta.Meta)
	return res, ok
}
func (fpv *Notification_FieldTerminalPathValue) AsAlertingPolicyValue() (*alerting_policy.Name, bool) {
	res, ok := fpv.value.(*alerting_policy.Name)
	return res, ok
}
func (fpv *Notification_FieldTerminalPathValue) AsAlertsValue() ([]*alert.Name, bool) {
	res, ok := fpv.value.([]*alert.Name)
	return res, ok
}
func (fpv *Notification_FieldTerminalPathValue) AsStateValue() (*Notification_State, bool) {
	res, ok := fpv.value.(*Notification_State)
	return res, ok
}

// SetTo stores value for selected field for object Notification
func (fpv *Notification_FieldTerminalPathValue) SetTo(target **Notification) {
	if *target == nil {
		*target = new(Notification)
	}
	switch fpv.selector {
	case Notification_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case Notification_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*ntt_meta.Meta)
	case Notification_FieldPathSelectorAlertingPolicy:
		(*target).AlertingPolicy = fpv.value.(*alerting_policy.Name)
	case Notification_FieldPathSelectorAlerts:
		(*target).Alerts = fpv.value.([]*alert.Name)
	case Notification_FieldPathSelectorState:
		(*target).State = fpv.value.(*Notification_State)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'Notification_FieldTerminalPathValue' with the value under path in 'Notification'.
func (fpv *Notification_FieldTerminalPathValue) CompareWith(source *Notification) (int, bool) {
	switch fpv.selector {
	case Notification_FieldPathSelectorName:
		leftValue := fpv.value.(*Name)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case Notification_FieldPathSelectorMetadata:
		return 0, false
	case Notification_FieldPathSelectorAlertingPolicy:
		leftValue := fpv.value.(*alerting_policy.Name)
		rightValue := source.GetAlertingPolicy()
		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 Notification_FieldPathSelectorAlerts:
		return 0, false
	case Notification_FieldPathSelectorState:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fpv.selector))
	}
}

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

type Notification_FieldSubPathValue struct {
	Notification_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ Notification_FieldPathValue = (*Notification_FieldSubPathValue)(nil)

func (fpvs *Notification_FieldSubPathValue) AsMetadataPathValue() (ntt_meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ntt_meta.Meta_FieldPathValue)
	return res, ok
}
func (fpvs *Notification_FieldSubPathValue) AsStatePathValue() (NotificationState_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationState_FieldPathValue)
	return res, ok
}

func (fpvs *Notification_FieldSubPathValue) SetTo(target **Notification) {
	if *target == nil {
		*target = new(Notification)
	}
	switch fpvs.Selector() {
	case Notification_FieldPathSelectorMetadata:
		fpvs.subPathValue.(ntt_meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	case Notification_FieldPathSelectorState:
		fpvs.subPathValue.(NotificationState_FieldPathValue).SetTo(&(*target).State)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *Notification_FieldSubPathValue) CompareWith(source *Notification) (int, bool) {
	switch fpvs.Selector() {
	case Notification_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(ntt_meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	case Notification_FieldPathSelectorState:
		return fpvs.subPathValue.(NotificationState_FieldPathValue).CompareWith(source.GetState())
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotification_FieldPathArrayItemValue(pathStr, valueStr string) Notification_FieldPathArrayItemValue {
	fpaiv, err := ParseNotification_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type Notification_FieldTerminalPathArrayItemValue struct {
	Notification_FieldTerminalPath
	value interface{}
}

var _ Notification_FieldPathArrayItemValue = (*Notification_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Notification as interface{}
func (fpaiv *Notification_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *Notification_FieldTerminalPathArrayItemValue) AsAlertsItemValue() (*alert.Name, bool) {
	res, ok := fpaiv.value.(*alert.Name)
	return res, ok
}

func (fpaiv *Notification_FieldTerminalPathArrayItemValue) GetSingle(source *Notification) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *Notification_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *Notification_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (ntt_meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ntt_meta.Meta_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Notification_FieldSubPathArrayItemValue) AsStatePathItemValue() (NotificationState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationState_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Notification'
func (fpaivs *Notification_FieldSubPathArrayItemValue) ContainsValue(source *Notification) bool {
	switch fpaivs.Selector() {
	case Notification_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(ntt_meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	case Notification_FieldPathSelectorState:
		return fpaivs.subPathItemValue.(NotificationState_FieldPathArrayItemValue).ContainsValue(source.GetState())
	default:
		panic(fmt.Sprintf("Invalid selector for Notification: %d", fpaivs.Selector()))
	}
}

// Notification_FieldPathArrayOfValues allows storing slice of values for Notification fields according to their type
type Notification_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	Notification_FieldPath
}

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

func MustParseNotification_FieldPathArrayOfValues(pathStr, valuesStr string) Notification_FieldPathArrayOfValues {
	fpaov, err := ParseNotification_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type Notification_FieldTerminalPathArrayOfValues struct {
	Notification_FieldTerminalPath
	values interface{}
}

var _ Notification_FieldPathArrayOfValues = (*Notification_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *Notification_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case Notification_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case Notification_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*ntt_meta.Meta) {
			values = append(values, v)
		}
	case Notification_FieldPathSelectorAlertingPolicy:
		for _, v := range fpaov.values.([]*alerting_policy.Name) {
			values = append(values, v)
		}
	case Notification_FieldPathSelectorAlerts:
		for _, v := range fpaov.values.([][]*alert.Name) {
			values = append(values, v)
		}
	case Notification_FieldPathSelectorState:
		for _, v := range fpaov.values.([]*Notification_State) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *Notification_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *Notification_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*ntt_meta.Meta, bool) {
	res, ok := fpaov.values.([]*ntt_meta.Meta)
	return res, ok
}
func (fpaov *Notification_FieldTerminalPathArrayOfValues) AsAlertingPolicyArrayOfValues() ([]*alerting_policy.Name, bool) {
	res, ok := fpaov.values.([]*alerting_policy.Name)
	return res, ok
}
func (fpaov *Notification_FieldTerminalPathArrayOfValues) AsAlertsArrayOfValues() ([][]*alert.Name, bool) {
	res, ok := fpaov.values.([][]*alert.Name)
	return res, ok
}
func (fpaov *Notification_FieldTerminalPathArrayOfValues) AsStateArrayOfValues() ([]*Notification_State, bool) {
	res, ok := fpaov.values.([]*Notification_State)
	return res, ok
}

type Notification_FieldSubPathArrayOfValues struct {
	Notification_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ Notification_FieldPathArrayOfValues = (*Notification_FieldSubPathArrayOfValues)(nil)

func (fpsaov *Notification_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *Notification_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (ntt_meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ntt_meta.Meta_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Notification_FieldSubPathArrayOfValues) AsStatePathArrayOfValues() (NotificationState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationState_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationState_FieldPathSelector int32

const (
	NotificationState_FieldPathSelectorIsResolved                   NotificationState_FieldPathSelector = 0
	NotificationState_FieldPathSelectorNotificationState            NotificationState_FieldPathSelector = 1
	NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone   NotificationState_FieldPathSelector = 2
	NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone NotificationState_FieldPathSelector = 3
	NotificationState_FieldPathSelectorAlertsLifetime               NotificationState_FieldPathSelector = 4
	NotificationState_FieldPathSelectorResolutionNotificationState  NotificationState_FieldPathSelector = 5
	NotificationState_FieldPathSelectorLifecycleCompleted           NotificationState_FieldPathSelector = 6
)

func (s NotificationState_FieldPathSelector) String() string {
	switch s {
	case NotificationState_FieldPathSelectorIsResolved:
		return "is_resolved"
	case NotificationState_FieldPathSelectorNotificationState:
		return "notification_state"
	case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
		return "incident_notify_attempts_done"
	case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
		return "resolution_notify_attempts_done"
	case NotificationState_FieldPathSelectorAlertsLifetime:
		return "alerts_lifetime"
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		return "resolution_notification_state"
	case NotificationState_FieldPathSelectorLifecycleCompleted:
		return "lifecycle_completed"
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", s))
	}
}

func BuildNotificationState_FieldPath(fp gotenobject.RawFieldPath) (NotificationState_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Notification_State")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "is_resolved", "isResolved", "is-resolved":
			return &NotificationState_FieldTerminalPath{selector: NotificationState_FieldPathSelectorIsResolved}, nil
		case "notification_state", "notificationState", "notification-state":
			return &NotificationState_FieldTerminalPath{selector: NotificationState_FieldPathSelectorNotificationState}, nil
		case "incident_notify_attempts_done", "incidentNotifyAttemptsDone", "incident-notify-attempts-done":
			return &NotificationState_FieldTerminalPath{selector: NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone}, nil
		case "resolution_notify_attempts_done", "resolutionNotifyAttemptsDone", "resolution-notify-attempts-done":
			return &NotificationState_FieldTerminalPath{selector: NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone}, nil
		case "alerts_lifetime", "alertsLifetime", "alerts-lifetime":
			return &NotificationState_FieldTerminalPath{selector: NotificationState_FieldPathSelectorAlertsLifetime}, nil
		case "resolution_notification_state", "resolutionNotificationState", "resolution-notification-state":
			return &NotificationState_FieldTerminalPath{selector: NotificationState_FieldPathSelectorResolutionNotificationState}, nil
		case "lifecycle_completed", "lifecycleCompleted", "lifecycle-completed":
			return &NotificationState_FieldTerminalPath{selector: NotificationState_FieldPathSelectorLifecycleCompleted}, nil
		}
	} else {
		switch fp[0] {
		case "notification_state", "notificationState", "notification-state":
			if subpath, err := BuildNotificationStateNotificationState_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationState_FieldSubPath{selector: NotificationState_FieldPathSelectorNotificationState, subPath: subpath}, nil
			}
		case "alerts_lifetime", "alertsLifetime", "alerts-lifetime":
			if subpath, err := monitoring_common.BuildTimeRange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationState_FieldSubPath{selector: NotificationState_FieldPathSelectorAlertsLifetime, subPath: subpath}, nil
			}
		case "resolution_notification_state", "resolutionNotificationState", "resolution-notification-state":
			if subpath, err := BuildNotificationStateNotificationState_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationState_FieldSubPath{selector: NotificationState_FieldPathSelectorResolutionNotificationState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Notification_State", fp)
}

func ParseNotificationState_FieldPath(rawField string) (NotificationState_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationState_FieldPath(fp)
}

func MustParseNotificationState_FieldPath(rawField string) NotificationState_FieldPath {
	fp, err := ParseNotificationState_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationState_FieldTerminalPath struct {
	selector NotificationState_FieldPathSelector
}

var _ NotificationState_FieldPath = (*NotificationState_FieldTerminalPath)(nil)

func (fp *NotificationState_FieldTerminalPath) Selector() NotificationState_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Notification_State
func (fp *NotificationState_FieldTerminalPath) Get(source *Notification_State) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationState_FieldPathSelectorIsResolved:
			values = append(values, source.IsResolved)
		case NotificationState_FieldPathSelectorNotificationState:
			for _, value := range source.GetNotificationState() {
				values = append(values, value)
			}
		case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
			values = append(values, source.IncidentNotifyAttemptsDone)
		case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
			values = append(values, source.ResolutionNotifyAttemptsDone)
		case NotificationState_FieldPathSelectorAlertsLifetime:
			if source.AlertsLifetime != nil {
				values = append(values, source.AlertsLifetime)
			}
		case NotificationState_FieldPathSelectorResolutionNotificationState:
			for _, value := range source.GetResolutionNotificationState() {
				values = append(values, value)
			}
		case NotificationState_FieldPathSelectorLifecycleCompleted:
			values = append(values, source.LifecycleCompleted)
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Notification_State
func (fp *NotificationState_FieldTerminalPath) GetSingle(source *Notification_State) (interface{}, bool) {
	switch fp.selector {
	case NotificationState_FieldPathSelectorIsResolved:
		return source.GetIsResolved(), source != nil
	case NotificationState_FieldPathSelectorNotificationState:
		res := source.GetNotificationState()
		return res, res != nil
	case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
		return source.GetIncidentNotifyAttemptsDone(), source != nil
	case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
		return source.GetResolutionNotifyAttemptsDone(), source != nil
	case NotificationState_FieldPathSelectorAlertsLifetime:
		res := source.GetAlertsLifetime()
		return res, res != nil
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		res := source.GetResolutionNotificationState()
		return res, res != nil
	case NotificationState_FieldPathSelectorLifecycleCompleted:
		return source.GetLifecycleCompleted(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationState_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationState_FieldPathSelectorIsResolved:
		return false
	case NotificationState_FieldPathSelectorNotificationState:
		return ([]*Notification_State_NotificationState)(nil)
	case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
		return false
	case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
		return false
	case NotificationState_FieldPathSelectorAlertsLifetime:
		return (*monitoring_common.TimeRange)(nil)
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		return ([]*Notification_State_NotificationState)(nil)
	case NotificationState_FieldPathSelectorLifecycleCompleted:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fp.selector))
	}
}

func (fp *NotificationState_FieldTerminalPath) ClearValue(item *Notification_State) {
	if item != nil {
		switch fp.selector {
		case NotificationState_FieldPathSelectorIsResolved:
			item.IsResolved = false
		case NotificationState_FieldPathSelectorNotificationState:
			item.NotificationState = nil
		case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
			item.IncidentNotifyAttemptsDone = false
		case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
			item.ResolutionNotifyAttemptsDone = false
		case NotificationState_FieldPathSelectorAlertsLifetime:
			item.AlertsLifetime = nil
		case NotificationState_FieldPathSelectorResolutionNotificationState:
			item.ResolutionNotificationState = nil
		case NotificationState_FieldPathSelectorLifecycleCompleted:
			item.LifecycleCompleted = false
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fp.selector))
		}
	}
}

func (fp *NotificationState_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Notification_State))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationState_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationState_FieldPathSelectorIsResolved ||
		fp.selector == NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone ||
		fp.selector == NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone ||
		fp.selector == NotificationState_FieldPathSelectorLifecycleCompleted
}

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

func (fp *NotificationState_FieldTerminalPath) WithIValue(value interface{}) NotificationState_FieldPathValue {
	switch fp.selector {
	case NotificationState_FieldPathSelectorIsResolved:
		return &NotificationState_FieldTerminalPathValue{NotificationState_FieldTerminalPath: *fp, value: value.(bool)}
	case NotificationState_FieldPathSelectorNotificationState:
		return &NotificationState_FieldTerminalPathValue{NotificationState_FieldTerminalPath: *fp, value: value.([]*Notification_State_NotificationState)}
	case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
		return &NotificationState_FieldTerminalPathValue{NotificationState_FieldTerminalPath: *fp, value: value.(bool)}
	case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
		return &NotificationState_FieldTerminalPathValue{NotificationState_FieldTerminalPath: *fp, value: value.(bool)}
	case NotificationState_FieldPathSelectorAlertsLifetime:
		return &NotificationState_FieldTerminalPathValue{NotificationState_FieldTerminalPath: *fp, value: value.(*monitoring_common.TimeRange)}
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		return &NotificationState_FieldTerminalPathValue{NotificationState_FieldTerminalPath: *fp, value: value.([]*Notification_State_NotificationState)}
	case NotificationState_FieldPathSelectorLifecycleCompleted:
		return &NotificationState_FieldTerminalPathValue{NotificationState_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fp.selector))
	}
}

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

func (fp *NotificationState_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationState_FieldPathArrayOfValues {
	fpaov := &NotificationState_FieldTerminalPathArrayOfValues{NotificationState_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationState_FieldPathSelectorIsResolved:
		return &NotificationState_FieldTerminalPathArrayOfValues{NotificationState_FieldTerminalPath: *fp, values: values.([]bool)}
	case NotificationState_FieldPathSelectorNotificationState:
		return &NotificationState_FieldTerminalPathArrayOfValues{NotificationState_FieldTerminalPath: *fp, values: values.([][]*Notification_State_NotificationState)}
	case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
		return &NotificationState_FieldTerminalPathArrayOfValues{NotificationState_FieldTerminalPath: *fp, values: values.([]bool)}
	case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
		return &NotificationState_FieldTerminalPathArrayOfValues{NotificationState_FieldTerminalPath: *fp, values: values.([]bool)}
	case NotificationState_FieldPathSelectorAlertsLifetime:
		return &NotificationState_FieldTerminalPathArrayOfValues{NotificationState_FieldTerminalPath: *fp, values: values.([]*monitoring_common.TimeRange)}
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		return &NotificationState_FieldTerminalPathArrayOfValues{NotificationState_FieldTerminalPath: *fp, values: values.([][]*Notification_State_NotificationState)}
	case NotificationState_FieldPathSelectorLifecycleCompleted:
		return &NotificationState_FieldTerminalPathArrayOfValues{NotificationState_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *NotificationState_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationState_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationState_FieldPathSelectorNotificationState:
		return &NotificationState_FieldTerminalPathArrayItemValue{NotificationState_FieldTerminalPath: *fp, value: value.(*Notification_State_NotificationState)}
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		return &NotificationState_FieldTerminalPathArrayItemValue{NotificationState_FieldTerminalPath: *fp, value: value.(*Notification_State_NotificationState)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fp.selector))
	}
}

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

type NotificationState_FieldSubPath struct {
	selector NotificationState_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationState_FieldPath = (*NotificationState_FieldSubPath)(nil)

func (fps *NotificationState_FieldSubPath) Selector() NotificationState_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationState_FieldSubPath) AsNotificationStateSubPath() (NotificationStateNotificationState_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationStateNotificationState_FieldPath)
	return res, ok
}
func (fps *NotificationState_FieldSubPath) AsAlertsLifetimeSubPath() (monitoring_common.TimeRange_FieldPath, bool) {
	res, ok := fps.subPath.(monitoring_common.TimeRange_FieldPath)
	return res, ok
}
func (fps *NotificationState_FieldSubPath) AsResolutionNotificationStateSubPath() (NotificationStateNotificationState_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationStateNotificationState_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source Notification_State
func (fps *NotificationState_FieldSubPath) Get(source *Notification_State) (values []interface{}) {
	switch fps.selector {
	case NotificationState_FieldPathSelectorNotificationState:
		for _, item := range source.GetNotificationState() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case NotificationState_FieldPathSelectorAlertsLifetime:
		values = append(values, fps.subPath.GetRaw(source.GetAlertsLifetime())...)
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		for _, item := range source.GetResolutionNotificationState() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source Notification_State
func (fps *NotificationState_FieldSubPath) GetSingle(source *Notification_State) (interface{}, bool) {
	switch fps.selector {
	case NotificationState_FieldPathSelectorNotificationState:
		if len(source.GetNotificationState()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetNotificationState()[0])
	case NotificationState_FieldPathSelectorAlertsLifetime:
		if source.GetAlertsLifetime() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAlertsLifetime())
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		if len(source.GetResolutionNotificationState()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetResolutionNotificationState()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fps.selector))
	}
}

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

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

func (fps *NotificationState_FieldSubPath) ClearValue(item *Notification_State) {
	if item != nil {
		switch fps.selector {
		case NotificationState_FieldPathSelectorNotificationState:
			for _, subItem := range item.NotificationState {
				fps.subPath.ClearValueRaw(subItem)
			}
		case NotificationState_FieldPathSelectorAlertsLifetime:
			fps.subPath.ClearValueRaw(item.AlertsLifetime)
		case NotificationState_FieldPathSelectorResolutionNotificationState:
			for _, subItem := range item.ResolutionNotificationState {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fps.selector))
		}
	}
}

func (fps *NotificationState_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Notification_State))
}

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

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

func (fps *NotificationState_FieldSubPath) WithIValue(value interface{}) NotificationState_FieldPathValue {
	return &NotificationState_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationState_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationState_FieldPathArrayOfValues {
	return &NotificationState_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationState_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationState_FieldPathArrayItemValue {
	return &NotificationState_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationState_FieldPathValue allows storing values for State fields according to their type
type NotificationState_FieldPathValue interface {
	NotificationState_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Notification_State)
	CompareWith(*Notification_State) (cmp int, comparable bool)
}

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

func MustParseNotificationState_FieldPathValue(pathStr, valueStr string) NotificationState_FieldPathValue {
	fpv, err := ParseNotificationState_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationState_FieldTerminalPathValue struct {
	NotificationState_FieldTerminalPath
	value interface{}
}

var _ NotificationState_FieldPathValue = (*NotificationState_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'State' as interface{}
func (fpv *NotificationState_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationState_FieldTerminalPathValue) AsIsResolvedValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *NotificationState_FieldTerminalPathValue) AsNotificationStateValue() ([]*Notification_State_NotificationState, bool) {
	res, ok := fpv.value.([]*Notification_State_NotificationState)
	return res, ok
}
func (fpv *NotificationState_FieldTerminalPathValue) AsIncidentNotifyAttemptsDoneValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *NotificationState_FieldTerminalPathValue) AsResolutionNotifyAttemptsDoneValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *NotificationState_FieldTerminalPathValue) AsAlertsLifetimeValue() (*monitoring_common.TimeRange, bool) {
	res, ok := fpv.value.(*monitoring_common.TimeRange)
	return res, ok
}
func (fpv *NotificationState_FieldTerminalPathValue) AsResolutionNotificationStateValue() ([]*Notification_State_NotificationState, bool) {
	res, ok := fpv.value.([]*Notification_State_NotificationState)
	return res, ok
}
func (fpv *NotificationState_FieldTerminalPathValue) AsLifecycleCompletedValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object State
func (fpv *NotificationState_FieldTerminalPathValue) SetTo(target **Notification_State) {
	if *target == nil {
		*target = new(Notification_State)
	}
	switch fpv.selector {
	case NotificationState_FieldPathSelectorIsResolved:
		(*target).IsResolved = fpv.value.(bool)
	case NotificationState_FieldPathSelectorNotificationState:
		(*target).NotificationState = fpv.value.([]*Notification_State_NotificationState)
	case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
		(*target).IncidentNotifyAttemptsDone = fpv.value.(bool)
	case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
		(*target).ResolutionNotifyAttemptsDone = fpv.value.(bool)
	case NotificationState_FieldPathSelectorAlertsLifetime:
		(*target).AlertsLifetime = fpv.value.(*monitoring_common.TimeRange)
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		(*target).ResolutionNotificationState = fpv.value.([]*Notification_State_NotificationState)
	case NotificationState_FieldPathSelectorLifecycleCompleted:
		(*target).LifecycleCompleted = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationState_FieldTerminalPathValue' with the value under path in 'Notification_State'.
func (fpv *NotificationState_FieldTerminalPathValue) CompareWith(source *Notification_State) (int, bool) {
	switch fpv.selector {
	case NotificationState_FieldPathSelectorIsResolved:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsResolved()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationState_FieldPathSelectorNotificationState:
		return 0, false
	case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIncidentNotifyAttemptsDone()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
		leftValue := fpv.value.(bool)
		rightValue := source.GetResolutionNotifyAttemptsDone()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationState_FieldPathSelectorAlertsLifetime:
		return 0, false
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		return 0, false
	case NotificationState_FieldPathSelectorLifecycleCompleted:
		leftValue := fpv.value.(bool)
		rightValue := source.GetLifecycleCompleted()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fpv.selector))
	}
}

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

type NotificationState_FieldSubPathValue struct {
	NotificationState_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationState_FieldPathValue = (*NotificationState_FieldSubPathValue)(nil)

func (fpvs *NotificationState_FieldSubPathValue) AsNotificationStatePathValue() (NotificationStateNotificationState_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationStateNotificationState_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationState_FieldSubPathValue) AsAlertsLifetimePathValue() (monitoring_common.TimeRange_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(monitoring_common.TimeRange_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationState_FieldSubPathValue) AsResolutionNotificationStatePathValue() (NotificationStateNotificationState_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationStateNotificationState_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationState_FieldSubPathValue) SetTo(target **Notification_State) {
	if *target == nil {
		*target = new(Notification_State)
	}
	switch fpvs.Selector() {
	case NotificationState_FieldPathSelectorNotificationState:
		panic("FieldPath setter is unsupported for array subpaths")
	case NotificationState_FieldPathSelectorAlertsLifetime:
		fpvs.subPathValue.(monitoring_common.TimeRange_FieldPathValue).SetTo(&(*target).AlertsLifetime)
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationState_FieldSubPathValue) CompareWith(source *Notification_State) (int, bool) {
	switch fpvs.Selector() {
	case NotificationState_FieldPathSelectorNotificationState:
		return 0, false // repeated field
	case NotificationState_FieldPathSelectorAlertsLifetime:
		return fpvs.subPathValue.(monitoring_common.TimeRange_FieldPathValue).CompareWith(source.GetAlertsLifetime())
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationState_FieldPathArrayItemValue(pathStr, valueStr string) NotificationState_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationState_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationState_FieldTerminalPathArrayItemValue struct {
	NotificationState_FieldTerminalPath
	value interface{}
}

var _ NotificationState_FieldPathArrayItemValue = (*NotificationState_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Notification_State as interface{}
func (fpaiv *NotificationState_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *NotificationState_FieldTerminalPathArrayItemValue) AsNotificationStateItemValue() (*Notification_State_NotificationState, bool) {
	res, ok := fpaiv.value.(*Notification_State_NotificationState)
	return res, ok
}
func (fpaiv *NotificationState_FieldTerminalPathArrayItemValue) AsResolutionNotificationStateItemValue() (*Notification_State_NotificationState, bool) {
	res, ok := fpaiv.value.(*Notification_State_NotificationState)
	return res, ok
}

func (fpaiv *NotificationState_FieldTerminalPathArrayItemValue) GetSingle(source *Notification_State) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'State'
func (fpaiv *NotificationState_FieldTerminalPathArrayItemValue) ContainsValue(source *Notification_State) bool {
	slice := fpaiv.NotificationState_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 NotificationState_FieldSubPathArrayItemValue struct {
	NotificationState_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *NotificationState_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationState_FieldSubPathArrayItemValue) AsNotificationStatePathItemValue() (NotificationStateNotificationState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationStateNotificationState_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationState_FieldSubPathArrayItemValue) AsAlertsLifetimePathItemValue() (monitoring_common.TimeRange_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(monitoring_common.TimeRange_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationState_FieldSubPathArrayItemValue) AsResolutionNotificationStatePathItemValue() (NotificationStateNotificationState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationStateNotificationState_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'State'
func (fpaivs *NotificationState_FieldSubPathArrayItemValue) ContainsValue(source *Notification_State) bool {
	switch fpaivs.Selector() {
	case NotificationState_FieldPathSelectorNotificationState:
		return false // repeated/map field
	case NotificationState_FieldPathSelectorAlertsLifetime:
		return fpaivs.subPathItemValue.(monitoring_common.TimeRange_FieldPathArrayItemValue).ContainsValue(source.GetAlertsLifetime())
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State: %d", fpaivs.Selector()))
	}
}

// NotificationState_FieldPathArrayOfValues allows storing slice of values for State fields according to their type
type NotificationState_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationState_FieldPath
}

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

func MustParseNotificationState_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationState_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationState_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationState_FieldTerminalPathArrayOfValues struct {
	NotificationState_FieldTerminalPath
	values interface{}
}

var _ NotificationState_FieldPathArrayOfValues = (*NotificationState_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationState_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationState_FieldPathSelectorIsResolved:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case NotificationState_FieldPathSelectorNotificationState:
		for _, v := range fpaov.values.([][]*Notification_State_NotificationState) {
			values = append(values, v)
		}
	case NotificationState_FieldPathSelectorIncidentNotifyAttemptsDone:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case NotificationState_FieldPathSelectorResolutionNotifyAttemptsDone:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case NotificationState_FieldPathSelectorAlertsLifetime:
		for _, v := range fpaov.values.([]*monitoring_common.TimeRange) {
			values = append(values, v)
		}
	case NotificationState_FieldPathSelectorResolutionNotificationState:
		for _, v := range fpaov.values.([][]*Notification_State_NotificationState) {
			values = append(values, v)
		}
	case NotificationState_FieldPathSelectorLifecycleCompleted:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationState_FieldTerminalPathArrayOfValues) AsIsResolvedArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *NotificationState_FieldTerminalPathArrayOfValues) AsNotificationStateArrayOfValues() ([][]*Notification_State_NotificationState, bool) {
	res, ok := fpaov.values.([][]*Notification_State_NotificationState)
	return res, ok
}
func (fpaov *NotificationState_FieldTerminalPathArrayOfValues) AsIncidentNotifyAttemptsDoneArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *NotificationState_FieldTerminalPathArrayOfValues) AsResolutionNotifyAttemptsDoneArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *NotificationState_FieldTerminalPathArrayOfValues) AsAlertsLifetimeArrayOfValues() ([]*monitoring_common.TimeRange, bool) {
	res, ok := fpaov.values.([]*monitoring_common.TimeRange)
	return res, ok
}
func (fpaov *NotificationState_FieldTerminalPathArrayOfValues) AsResolutionNotificationStateArrayOfValues() ([][]*Notification_State_NotificationState, bool) {
	res, ok := fpaov.values.([][]*Notification_State_NotificationState)
	return res, ok
}
func (fpaov *NotificationState_FieldTerminalPathArrayOfValues) AsLifecycleCompletedArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type NotificationState_FieldSubPathArrayOfValues struct {
	NotificationState_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationState_FieldPathArrayOfValues = (*NotificationState_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationState_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationState_FieldSubPathArrayOfValues) AsNotificationStatePathArrayOfValues() (NotificationStateNotificationState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationStateNotificationState_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationState_FieldSubPathArrayOfValues) AsAlertsLifetimePathArrayOfValues() (monitoring_common.TimeRange_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(monitoring_common.TimeRange_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationState_FieldSubPathArrayOfValues) AsResolutionNotificationStatePathArrayOfValues() (NotificationStateNotificationState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationStateNotificationState_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationStateNotificationState_FieldPathSelector int32

const (
	NotificationStateNotificationState_FieldPathSelectorNotificationChannel NotificationStateNotificationState_FieldPathSelector = 0
	NotificationStateNotificationState_FieldPathSelectorStatus              NotificationStateNotificationState_FieldPathSelector = 1
	NotificationStateNotificationState_FieldPathSelectorError               NotificationStateNotificationState_FieldPathSelector = 2
	NotificationStateNotificationState_FieldPathSelectorProviderData        NotificationStateNotificationState_FieldPathSelector = 3
	NotificationStateNotificationState_FieldPathSelectorNotifyAttempts      NotificationStateNotificationState_FieldPathSelector = 4
)

func (s NotificationStateNotificationState_FieldPathSelector) String() string {
	switch s {
	case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
		return "notification_channel"
	case NotificationStateNotificationState_FieldPathSelectorStatus:
		return "status"
	case NotificationStateNotificationState_FieldPathSelectorError:
		return "error"
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		return "provider_data"
	case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
		return "notify_attempts"
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", s))
	}
}

func BuildNotificationStateNotificationState_FieldPath(fp gotenobject.RawFieldPath) (NotificationStateNotificationState_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Notification_State_NotificationState")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "notification_channel", "notificationChannel", "notification-channel":
			return &NotificationStateNotificationState_FieldTerminalPath{selector: NotificationStateNotificationState_FieldPathSelectorNotificationChannel}, nil
		case "status":
			return &NotificationStateNotificationState_FieldTerminalPath{selector: NotificationStateNotificationState_FieldPathSelectorStatus}, nil
		case "error":
			return &NotificationStateNotificationState_FieldTerminalPath{selector: NotificationStateNotificationState_FieldPathSelectorError}, nil
		case "provider_data", "providerData", "provider-data":
			return &NotificationStateNotificationState_FieldTerminalPath{selector: NotificationStateNotificationState_FieldPathSelectorProviderData}, nil
		case "notify_attempts", "notifyAttempts", "notify-attempts":
			return &NotificationStateNotificationState_FieldTerminalPath{selector: NotificationStateNotificationState_FieldPathSelectorNotifyAttempts}, nil
		}
	} else {
		switch fp[0] {
		case "provider_data", "providerData", "provider-data":
			if subpath, err := BuildNotificationStateNotificationStateProviderData_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationStateNotificationState_FieldSubPath{selector: NotificationStateNotificationState_FieldPathSelectorProviderData, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Notification_State_NotificationState", fp)
}

func ParseNotificationStateNotificationState_FieldPath(rawField string) (NotificationStateNotificationState_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationStateNotificationState_FieldPath(fp)
}

func MustParseNotificationStateNotificationState_FieldPath(rawField string) NotificationStateNotificationState_FieldPath {
	fp, err := ParseNotificationStateNotificationState_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationStateNotificationState_FieldTerminalPath struct {
	selector NotificationStateNotificationState_FieldPathSelector
}

var _ NotificationStateNotificationState_FieldPath = (*NotificationStateNotificationState_FieldTerminalPath)(nil)

func (fp *NotificationStateNotificationState_FieldTerminalPath) Selector() NotificationStateNotificationState_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Notification_State_NotificationState
func (fp *NotificationStateNotificationState_FieldTerminalPath) Get(source *Notification_State_NotificationState) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
			if source.NotificationChannel != nil {
				values = append(values, source.NotificationChannel)
			}
		case NotificationStateNotificationState_FieldPathSelectorStatus:
			values = append(values, source.Status)
		case NotificationStateNotificationState_FieldPathSelectorError:
			values = append(values, source.Error)
		case NotificationStateNotificationState_FieldPathSelectorProviderData:
			if source.ProviderData != nil {
				values = append(values, source.ProviderData)
			}
		case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
			values = append(values, source.NotifyAttempts)
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Notification_State_NotificationState
func (fp *NotificationStateNotificationState_FieldTerminalPath) GetSingle(source *Notification_State_NotificationState) (interface{}, bool) {
	switch fp.selector {
	case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
		res := source.GetNotificationChannel()
		return res, res != nil
	case NotificationStateNotificationState_FieldPathSelectorStatus:
		return source.GetStatus(), source != nil
	case NotificationStateNotificationState_FieldPathSelectorError:
		return source.GetError(), source != nil
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		res := source.GetProviderData()
		return res, res != nil
	case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
		return source.GetNotifyAttempts(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationStateNotificationState_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
		return (*notification_channel.Name)(nil)
	case NotificationStateNotificationState_FieldPathSelectorStatus:
		return Notification_State_NotificationState_UNKNOWN
	case NotificationStateNotificationState_FieldPathSelectorError:
		return ""
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		return (*Notification_State_NotificationState_ProviderData)(nil)
	case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
		return int64(0)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fp.selector))
	}
}

func (fp *NotificationStateNotificationState_FieldTerminalPath) ClearValue(item *Notification_State_NotificationState) {
	if item != nil {
		switch fp.selector {
		case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
			item.NotificationChannel = nil
		case NotificationStateNotificationState_FieldPathSelectorStatus:
			item.Status = Notification_State_NotificationState_UNKNOWN
		case NotificationStateNotificationState_FieldPathSelectorError:
			item.Error = ""
		case NotificationStateNotificationState_FieldPathSelectorProviderData:
			item.ProviderData = nil
		case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
			item.NotifyAttempts = int64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fp.selector))
		}
	}
}

func (fp *NotificationStateNotificationState_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Notification_State_NotificationState))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationStateNotificationState_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationStateNotificationState_FieldPathSelectorNotificationChannel ||
		fp.selector == NotificationStateNotificationState_FieldPathSelectorStatus ||
		fp.selector == NotificationStateNotificationState_FieldPathSelectorError ||
		fp.selector == NotificationStateNotificationState_FieldPathSelectorNotifyAttempts
}

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

func (fp *NotificationStateNotificationState_FieldTerminalPath) WithIValue(value interface{}) NotificationStateNotificationState_FieldPathValue {
	switch fp.selector {
	case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
		return &NotificationStateNotificationState_FieldTerminalPathValue{NotificationStateNotificationState_FieldTerminalPath: *fp, value: value.(*notification_channel.Name)}
	case NotificationStateNotificationState_FieldPathSelectorStatus:
		return &NotificationStateNotificationState_FieldTerminalPathValue{NotificationStateNotificationState_FieldTerminalPath: *fp, value: value.(Notification_State_NotificationState_Status)}
	case NotificationStateNotificationState_FieldPathSelectorError:
		return &NotificationStateNotificationState_FieldTerminalPathValue{NotificationStateNotificationState_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		return &NotificationStateNotificationState_FieldTerminalPathValue{NotificationStateNotificationState_FieldTerminalPath: *fp, value: value.(*Notification_State_NotificationState_ProviderData)}
	case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
		return &NotificationStateNotificationState_FieldTerminalPathValue{NotificationStateNotificationState_FieldTerminalPath: *fp, value: value.(int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fp.selector))
	}
}

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

func (fp *NotificationStateNotificationState_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationStateNotificationState_FieldPathArrayOfValues {
	fpaov := &NotificationStateNotificationState_FieldTerminalPathArrayOfValues{NotificationStateNotificationState_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
		return &NotificationStateNotificationState_FieldTerminalPathArrayOfValues{NotificationStateNotificationState_FieldTerminalPath: *fp, values: values.([]*notification_channel.Name)}
	case NotificationStateNotificationState_FieldPathSelectorStatus:
		return &NotificationStateNotificationState_FieldTerminalPathArrayOfValues{NotificationStateNotificationState_FieldTerminalPath: *fp, values: values.([]Notification_State_NotificationState_Status)}
	case NotificationStateNotificationState_FieldPathSelectorError:
		return &NotificationStateNotificationState_FieldTerminalPathArrayOfValues{NotificationStateNotificationState_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		return &NotificationStateNotificationState_FieldTerminalPathArrayOfValues{NotificationStateNotificationState_FieldTerminalPath: *fp, values: values.([]*Notification_State_NotificationState_ProviderData)}
	case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
		return &NotificationStateNotificationState_FieldTerminalPathArrayOfValues{NotificationStateNotificationState_FieldTerminalPath: *fp, values: values.([]int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type NotificationStateNotificationState_FieldSubPath struct {
	selector NotificationStateNotificationState_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationStateNotificationState_FieldPath = (*NotificationStateNotificationState_FieldSubPath)(nil)

func (fps *NotificationStateNotificationState_FieldSubPath) Selector() NotificationStateNotificationState_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationStateNotificationState_FieldSubPath) AsProviderDataSubPath() (NotificationStateNotificationStateProviderData_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationStateNotificationStateProviderData_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *NotificationStateNotificationState_FieldSubPath) ClearValue(item *Notification_State_NotificationState) {
	if item != nil {
		switch fps.selector {
		case NotificationStateNotificationState_FieldPathSelectorProviderData:
			fps.subPath.ClearValueRaw(item.ProviderData)
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fps.selector))
		}
	}
}

func (fps *NotificationStateNotificationState_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Notification_State_NotificationState))
}

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

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

func (fps *NotificationStateNotificationState_FieldSubPath) WithIValue(value interface{}) NotificationStateNotificationState_FieldPathValue {
	return &NotificationStateNotificationState_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationStateNotificationState_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationStateNotificationState_FieldPathArrayOfValues {
	return &NotificationStateNotificationState_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationStateNotificationState_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationStateNotificationState_FieldPathArrayItemValue {
	return &NotificationStateNotificationState_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationStateNotificationState_FieldPathValue allows storing values for NotificationState fields according to their type
type NotificationStateNotificationState_FieldPathValue interface {
	NotificationStateNotificationState_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Notification_State_NotificationState)
	CompareWith(*Notification_State_NotificationState) (cmp int, comparable bool)
}

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

func MustParseNotificationStateNotificationState_FieldPathValue(pathStr, valueStr string) NotificationStateNotificationState_FieldPathValue {
	fpv, err := ParseNotificationStateNotificationState_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationStateNotificationState_FieldTerminalPathValue struct {
	NotificationStateNotificationState_FieldTerminalPath
	value interface{}
}

var _ NotificationStateNotificationState_FieldPathValue = (*NotificationStateNotificationState_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'NotificationState' as interface{}
func (fpv *NotificationStateNotificationState_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationStateNotificationState_FieldTerminalPathValue) AsNotificationChannelValue() (*notification_channel.Name, bool) {
	res, ok := fpv.value.(*notification_channel.Name)
	return res, ok
}
func (fpv *NotificationStateNotificationState_FieldTerminalPathValue) AsStatusValue() (Notification_State_NotificationState_Status, bool) {
	res, ok := fpv.value.(Notification_State_NotificationState_Status)
	return res, ok
}
func (fpv *NotificationStateNotificationState_FieldTerminalPathValue) AsErrorValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationStateNotificationState_FieldTerminalPathValue) AsProviderDataValue() (*Notification_State_NotificationState_ProviderData, bool) {
	res, ok := fpv.value.(*Notification_State_NotificationState_ProviderData)
	return res, ok
}
func (fpv *NotificationStateNotificationState_FieldTerminalPathValue) AsNotifyAttemptsValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}

// SetTo stores value for selected field for object NotificationState
func (fpv *NotificationStateNotificationState_FieldTerminalPathValue) SetTo(target **Notification_State_NotificationState) {
	if *target == nil {
		*target = new(Notification_State_NotificationState)
	}
	switch fpv.selector {
	case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
		(*target).NotificationChannel = fpv.value.(*notification_channel.Name)
	case NotificationStateNotificationState_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(Notification_State_NotificationState_Status)
	case NotificationStateNotificationState_FieldPathSelectorError:
		(*target).Error = fpv.value.(string)
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		(*target).ProviderData = fpv.value.(*Notification_State_NotificationState_ProviderData)
	case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
		(*target).NotifyAttempts = fpv.value.(int64)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationStateNotificationState_FieldTerminalPathValue' with the value under path in 'Notification_State_NotificationState'.
func (fpv *NotificationStateNotificationState_FieldTerminalPathValue) CompareWith(source *Notification_State_NotificationState) (int, bool) {
	switch fpv.selector {
	case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
		leftValue := fpv.value.(*notification_channel.Name)
		rightValue := source.GetNotificationChannel()
		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 NotificationStateNotificationState_FieldPathSelectorStatus:
		leftValue := fpv.value.(Notification_State_NotificationState_Status)
		rightValue := source.GetStatus()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationStateNotificationState_FieldPathSelectorError:
		leftValue := fpv.value.(string)
		rightValue := source.GetError()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		return 0, false
	case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
		leftValue := fpv.value.(int64)
		rightValue := source.GetNotifyAttempts()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fpv.selector))
	}
}

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

type NotificationStateNotificationState_FieldSubPathValue struct {
	NotificationStateNotificationState_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationStateNotificationState_FieldPathValue = (*NotificationStateNotificationState_FieldSubPathValue)(nil)

func (fpvs *NotificationStateNotificationState_FieldSubPathValue) AsProviderDataPathValue() (NotificationStateNotificationStateProviderData_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationStateNotificationStateProviderData_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationStateNotificationState_FieldSubPathValue) SetTo(target **Notification_State_NotificationState) {
	if *target == nil {
		*target = new(Notification_State_NotificationState)
	}
	switch fpvs.Selector() {
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		fpvs.subPathValue.(NotificationStateNotificationStateProviderData_FieldPathValue).SetTo(&(*target).ProviderData)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationStateNotificationState_FieldSubPathValue) CompareWith(source *Notification_State_NotificationState) (int, bool) {
	switch fpvs.Selector() {
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		return fpvs.subPathValue.(NotificationStateNotificationStateProviderData_FieldPathValue).CompareWith(source.GetProviderData())
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationStateNotificationState_FieldPathArrayItemValue(pathStr, valueStr string) NotificationStateNotificationState_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationStateNotificationState_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationStateNotificationState_FieldTerminalPathArrayItemValue struct {
	NotificationStateNotificationState_FieldTerminalPath
	value interface{}
}

var _ NotificationStateNotificationState_FieldPathArrayItemValue = (*NotificationStateNotificationState_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationStateNotificationState_FieldTerminalPathArrayItemValue) GetSingle(source *Notification_State_NotificationState) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'NotificationState'
func (fpaiv *NotificationStateNotificationState_FieldTerminalPathArrayItemValue) ContainsValue(source *Notification_State_NotificationState) bool {
	slice := fpaiv.NotificationStateNotificationState_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 NotificationStateNotificationState_FieldSubPathArrayItemValue struct {
	NotificationStateNotificationState_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'NotificationState'
func (fpaivs *NotificationStateNotificationState_FieldSubPathArrayItemValue) ContainsValue(source *Notification_State_NotificationState) bool {
	switch fpaivs.Selector() {
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		return fpaivs.subPathItemValue.(NotificationStateNotificationStateProviderData_FieldPathArrayItemValue).ContainsValue(source.GetProviderData())
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState: %d", fpaivs.Selector()))
	}
}

// NotificationStateNotificationState_FieldPathArrayOfValues allows storing slice of values for NotificationState fields according to their type
type NotificationStateNotificationState_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationStateNotificationState_FieldPath
}

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

func MustParseNotificationStateNotificationState_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationStateNotificationState_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationStateNotificationState_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationStateNotificationState_FieldTerminalPathArrayOfValues struct {
	NotificationStateNotificationState_FieldTerminalPath
	values interface{}
}

var _ NotificationStateNotificationState_FieldPathArrayOfValues = (*NotificationStateNotificationState_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationStateNotificationState_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationStateNotificationState_FieldPathSelectorNotificationChannel:
		for _, v := range fpaov.values.([]*notification_channel.Name) {
			values = append(values, v)
		}
	case NotificationStateNotificationState_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]Notification_State_NotificationState_Status) {
			values = append(values, v)
		}
	case NotificationStateNotificationState_FieldPathSelectorError:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationStateNotificationState_FieldPathSelectorProviderData:
		for _, v := range fpaov.values.([]*Notification_State_NotificationState_ProviderData) {
			values = append(values, v)
		}
	case NotificationStateNotificationState_FieldPathSelectorNotifyAttempts:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationStateNotificationState_FieldTerminalPathArrayOfValues) AsNotificationChannelArrayOfValues() ([]*notification_channel.Name, bool) {
	res, ok := fpaov.values.([]*notification_channel.Name)
	return res, ok
}
func (fpaov *NotificationStateNotificationState_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]Notification_State_NotificationState_Status, bool) {
	res, ok := fpaov.values.([]Notification_State_NotificationState_Status)
	return res, ok
}
func (fpaov *NotificationStateNotificationState_FieldTerminalPathArrayOfValues) AsErrorArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationStateNotificationState_FieldTerminalPathArrayOfValues) AsProviderDataArrayOfValues() ([]*Notification_State_NotificationState_ProviderData, bool) {
	res, ok := fpaov.values.([]*Notification_State_NotificationState_ProviderData)
	return res, ok
}
func (fpaov *NotificationStateNotificationState_FieldTerminalPathArrayOfValues) AsNotifyAttemptsArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}

type NotificationStateNotificationState_FieldSubPathArrayOfValues struct {
	NotificationStateNotificationState_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationStateNotificationState_FieldPathArrayOfValues = (*NotificationStateNotificationState_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationStateNotificationState_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationStateNotificationState_FieldSubPathArrayOfValues) AsProviderDataPathArrayOfValues() (NotificationStateNotificationStateProviderData_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationStateNotificationStateProviderData_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationStateNotificationStateProviderData_FieldPathSelector int32

const (
	NotificationStateNotificationStateProviderData_FieldPathSelectorSlack     NotificationStateNotificationStateProviderData_FieldPathSelector = 0
	NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty NotificationStateNotificationStateProviderData_FieldPathSelector = 1
)

func (s NotificationStateNotificationStateProviderData_FieldPathSelector) String() string {
	switch s {
	case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
		return "slack"
	case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
		return "pager_duty"
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", s))
	}
}

func BuildNotificationStateNotificationStateProviderData_FieldPath(fp gotenobject.RawFieldPath) (NotificationStateNotificationStateProviderData_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Notification_State_NotificationState_ProviderData")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "slack":
			return &NotificationStateNotificationStateProviderData_FieldTerminalPath{selector: NotificationStateNotificationStateProviderData_FieldPathSelectorSlack}, nil
		case "pager_duty", "pagerDuty", "pager-duty":
			return &NotificationStateNotificationStateProviderData_FieldTerminalPath{selector: NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty}, nil
		}
	} else {
		switch fp[0] {
		case "slack":
			if subpath, err := BuildNotificationStateNotificationStateProviderDataSlack_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationStateNotificationStateProviderData_FieldSubPath{selector: NotificationStateNotificationStateProviderData_FieldPathSelectorSlack, subPath: subpath}, nil
			}
		case "pager_duty", "pagerDuty", "pager-duty":
			if subpath, err := BuildNotificationStateNotificationStateProviderDataPagerDuty_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationStateNotificationStateProviderData_FieldSubPath{selector: NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Notification_State_NotificationState_ProviderData", fp)
}

func ParseNotificationStateNotificationStateProviderData_FieldPath(rawField string) (NotificationStateNotificationStateProviderData_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationStateNotificationStateProviderData_FieldPath(fp)
}

func MustParseNotificationStateNotificationStateProviderData_FieldPath(rawField string) NotificationStateNotificationStateProviderData_FieldPath {
	fp, err := ParseNotificationStateNotificationStateProviderData_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationStateNotificationStateProviderData_FieldTerminalPath struct {
	selector NotificationStateNotificationStateProviderData_FieldPathSelector
}

var _ NotificationStateNotificationStateProviderData_FieldPath = (*NotificationStateNotificationStateProviderData_FieldTerminalPath)(nil)

func (fp *NotificationStateNotificationStateProviderData_FieldTerminalPath) Selector() NotificationStateNotificationStateProviderData_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *NotificationStateNotificationStateProviderData_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
		return (*Notification_State_NotificationState_ProviderData_Slack)(nil)
	case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
		return (*Notification_State_NotificationState_ProviderData_PagerDuty)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", fp.selector))
	}
}

func (fp *NotificationStateNotificationStateProviderData_FieldTerminalPath) ClearValue(item *Notification_State_NotificationState_ProviderData) {
	if item != nil {
		switch fp.selector {
		case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
			item.Slack = nil
		case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
			item.PagerDuty = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", fp.selector))
		}
	}
}

func (fp *NotificationStateNotificationStateProviderData_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Notification_State_NotificationState_ProviderData))
}

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

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

func (fp *NotificationStateNotificationStateProviderData_FieldTerminalPath) WithIValue(value interface{}) NotificationStateNotificationStateProviderData_FieldPathValue {
	switch fp.selector {
	case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
		return &NotificationStateNotificationStateProviderData_FieldTerminalPathValue{NotificationStateNotificationStateProviderData_FieldTerminalPath: *fp, value: value.(*Notification_State_NotificationState_ProviderData_Slack)}
	case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
		return &NotificationStateNotificationStateProviderData_FieldTerminalPathValue{NotificationStateNotificationStateProviderData_FieldTerminalPath: *fp, value: value.(*Notification_State_NotificationState_ProviderData_PagerDuty)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", fp.selector))
	}
}

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

func (fp *NotificationStateNotificationStateProviderData_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationStateNotificationStateProviderData_FieldPathArrayOfValues {
	fpaov := &NotificationStateNotificationStateProviderData_FieldTerminalPathArrayOfValues{NotificationStateNotificationStateProviderData_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
		return &NotificationStateNotificationStateProviderData_FieldTerminalPathArrayOfValues{NotificationStateNotificationStateProviderData_FieldTerminalPath: *fp, values: values.([]*Notification_State_NotificationState_ProviderData_Slack)}
	case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
		return &NotificationStateNotificationStateProviderData_FieldTerminalPathArrayOfValues{NotificationStateNotificationStateProviderData_FieldTerminalPath: *fp, values: values.([]*Notification_State_NotificationState_ProviderData_PagerDuty)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type NotificationStateNotificationStateProviderData_FieldSubPath struct {
	selector NotificationStateNotificationStateProviderData_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationStateNotificationStateProviderData_FieldPath = (*NotificationStateNotificationStateProviderData_FieldSubPath)(nil)

func (fps *NotificationStateNotificationStateProviderData_FieldSubPath) Selector() NotificationStateNotificationStateProviderData_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationStateNotificationStateProviderData_FieldSubPath) AsSlackSubPath() (NotificationStateNotificationStateProviderDataSlack_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationStateNotificationStateProviderDataSlack_FieldPath)
	return res, ok
}
func (fps *NotificationStateNotificationStateProviderData_FieldSubPath) AsPagerDutySubPath() (NotificationStateNotificationStateProviderDataPagerDuty_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationStateNotificationStateProviderDataPagerDuty_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *NotificationStateNotificationStateProviderData_FieldSubPath) ClearValue(item *Notification_State_NotificationState_ProviderData) {
	if item != nil {
		switch fps.selector {
		case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
			fps.subPath.ClearValueRaw(item.Slack)
		case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
			fps.subPath.ClearValueRaw(item.PagerDuty)
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", fps.selector))
		}
	}
}

func (fps *NotificationStateNotificationStateProviderData_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Notification_State_NotificationState_ProviderData))
}

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

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

func (fps *NotificationStateNotificationStateProviderData_FieldSubPath) WithIValue(value interface{}) NotificationStateNotificationStateProviderData_FieldPathValue {
	return &NotificationStateNotificationStateProviderData_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationStateNotificationStateProviderData_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationStateNotificationStateProviderData_FieldPathArrayOfValues {
	return &NotificationStateNotificationStateProviderData_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationStateNotificationStateProviderData_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationStateNotificationStateProviderData_FieldPathArrayItemValue {
	return &NotificationStateNotificationStateProviderData_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationStateNotificationStateProviderData_FieldPathValue allows storing values for ProviderData fields according to their type
type NotificationStateNotificationStateProviderData_FieldPathValue interface {
	NotificationStateNotificationStateProviderData_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Notification_State_NotificationState_ProviderData)
	CompareWith(*Notification_State_NotificationState_ProviderData) (cmp int, comparable bool)
}

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

func MustParseNotificationStateNotificationStateProviderData_FieldPathValue(pathStr, valueStr string) NotificationStateNotificationStateProviderData_FieldPathValue {
	fpv, err := ParseNotificationStateNotificationStateProviderData_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationStateNotificationStateProviderData_FieldTerminalPathValue struct {
	NotificationStateNotificationStateProviderData_FieldTerminalPath
	value interface{}
}

var _ NotificationStateNotificationStateProviderData_FieldPathValue = (*NotificationStateNotificationStateProviderData_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ProviderData' as interface{}
func (fpv *NotificationStateNotificationStateProviderData_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationStateNotificationStateProviderData_FieldTerminalPathValue) AsSlackValue() (*Notification_State_NotificationState_ProviderData_Slack, bool) {
	res, ok := fpv.value.(*Notification_State_NotificationState_ProviderData_Slack)
	return res, ok
}
func (fpv *NotificationStateNotificationStateProviderData_FieldTerminalPathValue) AsPagerDutyValue() (*Notification_State_NotificationState_ProviderData_PagerDuty, bool) {
	res, ok := fpv.value.(*Notification_State_NotificationState_ProviderData_PagerDuty)
	return res, ok
}

// SetTo stores value for selected field for object ProviderData
func (fpv *NotificationStateNotificationStateProviderData_FieldTerminalPathValue) SetTo(target **Notification_State_NotificationState_ProviderData) {
	if *target == nil {
		*target = new(Notification_State_NotificationState_ProviderData)
	}
	switch fpv.selector {
	case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
		(*target).Slack = fpv.value.(*Notification_State_NotificationState_ProviderData_Slack)
	case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
		(*target).PagerDuty = fpv.value.(*Notification_State_NotificationState_ProviderData_PagerDuty)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", fpv.selector))
	}
}

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

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

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

type NotificationStateNotificationStateProviderData_FieldSubPathValue struct {
	NotificationStateNotificationStateProviderData_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationStateNotificationStateProviderData_FieldPathValue = (*NotificationStateNotificationStateProviderData_FieldSubPathValue)(nil)

func (fpvs *NotificationStateNotificationStateProviderData_FieldSubPathValue) AsSlackPathValue() (NotificationStateNotificationStateProviderDataSlack_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationStateNotificationStateProviderDataSlack_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationStateNotificationStateProviderData_FieldSubPathValue) AsPagerDutyPathValue() (NotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationStateNotificationStateProviderData_FieldSubPathValue) SetTo(target **Notification_State_NotificationState_ProviderData) {
	if *target == nil {
		*target = new(Notification_State_NotificationState_ProviderData)
	}
	switch fpvs.Selector() {
	case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
		fpvs.subPathValue.(NotificationStateNotificationStateProviderDataSlack_FieldPathValue).SetTo(&(*target).Slack)
	case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
		fpvs.subPathValue.(NotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue).SetTo(&(*target).PagerDuty)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationStateNotificationStateProviderData_FieldSubPathValue) CompareWith(source *Notification_State_NotificationState_ProviderData) (int, bool) {
	switch fpvs.Selector() {
	case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
		return fpvs.subPathValue.(NotificationStateNotificationStateProviderDataSlack_FieldPathValue).CompareWith(source.GetSlack())
	case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
		return fpvs.subPathValue.(NotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue).CompareWith(source.GetPagerDuty())
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationStateNotificationStateProviderData_FieldPathArrayItemValue(pathStr, valueStr string) NotificationStateNotificationStateProviderData_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationStateNotificationStateProviderData_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationStateNotificationStateProviderData_FieldTerminalPathArrayItemValue struct {
	NotificationStateNotificationStateProviderData_FieldTerminalPath
	value interface{}
}

var _ NotificationStateNotificationStateProviderData_FieldPathArrayItemValue = (*NotificationStateNotificationStateProviderData_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationStateNotificationStateProviderData_FieldTerminalPathArrayItemValue) GetSingle(source *Notification_State_NotificationState_ProviderData) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ProviderData'
func (fpaiv *NotificationStateNotificationStateProviderData_FieldTerminalPathArrayItemValue) ContainsValue(source *Notification_State_NotificationState_ProviderData) bool {
	slice := fpaiv.NotificationStateNotificationStateProviderData_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 NotificationStateNotificationStateProviderData_FieldSubPathArrayItemValue struct {
	NotificationStateNotificationStateProviderData_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *NotificationStateNotificationStateProviderData_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationStateNotificationStateProviderData_FieldSubPathArrayItemValue) AsSlackPathItemValue() (NotificationStateNotificationStateProviderDataSlack_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationStateNotificationStateProviderDataSlack_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationStateNotificationStateProviderData_FieldSubPathArrayItemValue) AsPagerDutyPathItemValue() (NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ProviderData'
func (fpaivs *NotificationStateNotificationStateProviderData_FieldSubPathArrayItemValue) ContainsValue(source *Notification_State_NotificationState_ProviderData) bool {
	switch fpaivs.Selector() {
	case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
		return fpaivs.subPathItemValue.(NotificationStateNotificationStateProviderDataSlack_FieldPathArrayItemValue).ContainsValue(source.GetSlack())
	case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
		return fpaivs.subPathItemValue.(NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayItemValue).ContainsValue(source.GetPagerDuty())
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData: %d", fpaivs.Selector()))
	}
}

// NotificationStateNotificationStateProviderData_FieldPathArrayOfValues allows storing slice of values for ProviderData fields according to their type
type NotificationStateNotificationStateProviderData_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationStateNotificationStateProviderData_FieldPath
}

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

func MustParseNotificationStateNotificationStateProviderData_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationStateNotificationStateProviderData_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationStateNotificationStateProviderData_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationStateNotificationStateProviderData_FieldTerminalPathArrayOfValues struct {
	NotificationStateNotificationStateProviderData_FieldTerminalPath
	values interface{}
}

var _ NotificationStateNotificationStateProviderData_FieldPathArrayOfValues = (*NotificationStateNotificationStateProviderData_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationStateNotificationStateProviderData_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationStateNotificationStateProviderData_FieldPathSelectorSlack:
		for _, v := range fpaov.values.([]*Notification_State_NotificationState_ProviderData_Slack) {
			values = append(values, v)
		}
	case NotificationStateNotificationStateProviderData_FieldPathSelectorPagerDuty:
		for _, v := range fpaov.values.([]*Notification_State_NotificationState_ProviderData_PagerDuty) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationStateNotificationStateProviderData_FieldTerminalPathArrayOfValues) AsSlackArrayOfValues() ([]*Notification_State_NotificationState_ProviderData_Slack, bool) {
	res, ok := fpaov.values.([]*Notification_State_NotificationState_ProviderData_Slack)
	return res, ok
}
func (fpaov *NotificationStateNotificationStateProviderData_FieldTerminalPathArrayOfValues) AsPagerDutyArrayOfValues() ([]*Notification_State_NotificationState_ProviderData_PagerDuty, bool) {
	res, ok := fpaov.values.([]*Notification_State_NotificationState_ProviderData_PagerDuty)
	return res, ok
}

type NotificationStateNotificationStateProviderData_FieldSubPathArrayOfValues struct {
	NotificationStateNotificationStateProviderData_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationStateNotificationStateProviderData_FieldPathArrayOfValues = (*NotificationStateNotificationStateProviderData_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationStateNotificationStateProviderData_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationStateNotificationStateProviderData_FieldSubPathArrayOfValues) AsSlackPathArrayOfValues() (NotificationStateNotificationStateProviderDataSlack_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationStateNotificationStateProviderDataSlack_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationStateNotificationStateProviderData_FieldSubPathArrayOfValues) AsPagerDutyPathArrayOfValues() (NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationStateNotificationStateProviderDataSlack_FieldPathSelector int32

const (
	NotificationStateNotificationStateProviderDataSlack_FieldPathSelectorTs NotificationStateNotificationStateProviderDataSlack_FieldPathSelector = 0
)

func (s NotificationStateNotificationStateProviderDataSlack_FieldPathSelector) String() string {
	switch s {
	case NotificationStateNotificationStateProviderDataSlack_FieldPathSelectorTs:
		return "ts"
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_Slack: %d", s))
	}
}

func BuildNotificationStateNotificationStateProviderDataSlack_FieldPath(fp gotenobject.RawFieldPath) (NotificationStateNotificationStateProviderDataSlack_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Notification_State_NotificationState_ProviderData_Slack")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "ts":
			return &NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath{selector: NotificationStateNotificationStateProviderDataSlack_FieldPathSelectorTs}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Notification_State_NotificationState_ProviderData_Slack", fp)
}

func ParseNotificationStateNotificationStateProviderDataSlack_FieldPath(rawField string) (NotificationStateNotificationStateProviderDataSlack_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationStateNotificationStateProviderDataSlack_FieldPath(fp)
}

func MustParseNotificationStateNotificationStateProviderDataSlack_FieldPath(rawField string) NotificationStateNotificationStateProviderDataSlack_FieldPath {
	fp, err := ParseNotificationStateNotificationStateProviderDataSlack_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath struct {
	selector NotificationStateNotificationStateProviderDataSlack_FieldPathSelector
}

var _ NotificationStateNotificationStateProviderDataSlack_FieldPath = (*NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath)(nil)

func (fp *NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath) Selector() NotificationStateNotificationStateProviderDataSlack_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath) ClearValue(item *Notification_State_NotificationState_ProviderData_Slack) {
	if item != nil {
		switch fp.selector {
		case NotificationStateNotificationStateProviderDataSlack_FieldPathSelectorTs:
			item.Ts = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_Slack: %d", fp.selector))
		}
	}
}

func (fp *NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Notification_State_NotificationState_ProviderData_Slack))
}

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

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

func (fp *NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath) WithIValue(value interface{}) NotificationStateNotificationStateProviderDataSlack_FieldPathValue {
	switch fp.selector {
	case NotificationStateNotificationStateProviderDataSlack_FieldPathSelectorTs:
		return &NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathValue{NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_Slack: %d", fp.selector))
	}
}

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

func (fp *NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationStateNotificationStateProviderDataSlack_FieldPathArrayOfValues {
	fpaov := &NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathArrayOfValues{NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationStateNotificationStateProviderDataSlack_FieldPathSelectorTs:
		return &NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathArrayOfValues{NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_Slack: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// NotificationStateNotificationStateProviderDataSlack_FieldPathValue allows storing values for Slack fields according to their type
type NotificationStateNotificationStateProviderDataSlack_FieldPathValue interface {
	NotificationStateNotificationStateProviderDataSlack_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Notification_State_NotificationState_ProviderData_Slack)
	CompareWith(*Notification_State_NotificationState_ProviderData_Slack) (cmp int, comparable bool)
}

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

func MustParseNotificationStateNotificationStateProviderDataSlack_FieldPathValue(pathStr, valueStr string) NotificationStateNotificationStateProviderDataSlack_FieldPathValue {
	fpv, err := ParseNotificationStateNotificationStateProviderDataSlack_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathValue struct {
	NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath
	value interface{}
}

var _ NotificationStateNotificationStateProviderDataSlack_FieldPathValue = (*NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object Slack
func (fpv *NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathValue) SetTo(target **Notification_State_NotificationState_ProviderData_Slack) {
	if *target == nil {
		*target = new(Notification_State_NotificationState_ProviderData_Slack)
	}
	switch fpv.selector {
	case NotificationStateNotificationStateProviderDataSlack_FieldPathSelectorTs:
		(*target).Ts = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_Slack: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseNotificationStateNotificationStateProviderDataSlack_FieldPathArrayItemValue(pathStr, valueStr string) NotificationStateNotificationStateProviderDataSlack_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationStateNotificationStateProviderDataSlack_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathArrayItemValue struct {
	NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath
	value interface{}
}

var _ NotificationStateNotificationStateProviderDataSlack_FieldPathArrayItemValue = (*NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathArrayItemValue) GetSingle(source *Notification_State_NotificationState_ProviderData_Slack) (interface{}, bool) {
	return nil, false
}

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

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

// NotificationStateNotificationStateProviderDataSlack_FieldPathArrayOfValues allows storing slice of values for Slack fields according to their type
type NotificationStateNotificationStateProviderDataSlack_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationStateNotificationStateProviderDataSlack_FieldPath
}

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

func MustParseNotificationStateNotificationStateProviderDataSlack_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationStateNotificationStateProviderDataSlack_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationStateNotificationStateProviderDataSlack_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathArrayOfValues struct {
	NotificationStateNotificationStateProviderDataSlack_FieldTerminalPath
	values interface{}
}

var _ NotificationStateNotificationStateProviderDataSlack_FieldPathArrayOfValues = (*NotificationStateNotificationStateProviderDataSlack_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelector int32

const (
	NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelectorIncidentKey NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelector = 0
)

func (s NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelector) String() string {
	switch s {
	case NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelectorIncidentKey:
		return "incident_key"
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_PagerDuty: %d", s))
	}
}

func BuildNotificationStateNotificationStateProviderDataPagerDuty_FieldPath(fp gotenobject.RawFieldPath) (NotificationStateNotificationStateProviderDataPagerDuty_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Notification_State_NotificationState_ProviderData_PagerDuty")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "incident_key", "incidentKey", "incident-key":
			return &NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath{selector: NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelectorIncidentKey}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Notification_State_NotificationState_ProviderData_PagerDuty", fp)
}

func ParseNotificationStateNotificationStateProviderDataPagerDuty_FieldPath(rawField string) (NotificationStateNotificationStateProviderDataPagerDuty_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationStateNotificationStateProviderDataPagerDuty_FieldPath(fp)
}

func MustParseNotificationStateNotificationStateProviderDataPagerDuty_FieldPath(rawField string) NotificationStateNotificationStateProviderDataPagerDuty_FieldPath {
	fp, err := ParseNotificationStateNotificationStateProviderDataPagerDuty_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath struct {
	selector NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelector
}

var _ NotificationStateNotificationStateProviderDataPagerDuty_FieldPath = (*NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath)(nil)

func (fp *NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath) Selector() NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath) ClearValue(item *Notification_State_NotificationState_ProviderData_PagerDuty) {
	if item != nil {
		switch fp.selector {
		case NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelectorIncidentKey:
			item.IncidentKey = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_PagerDuty: %d", fp.selector))
		}
	}
}

func (fp *NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Notification_State_NotificationState_ProviderData_PagerDuty))
}

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

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

func (fp *NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath) WithIValue(value interface{}) NotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue {
	switch fp.selector {
	case NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelectorIncidentKey:
		return &NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathValue{NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_PagerDuty: %d", fp.selector))
	}
}

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

func (fp *NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayOfValues {
	fpaov := &NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathArrayOfValues{NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelectorIncidentKey:
		return &NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathArrayOfValues{NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_PagerDuty: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// NotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue allows storing values for PagerDuty fields according to their type
type NotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue interface {
	NotificationStateNotificationStateProviderDataPagerDuty_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Notification_State_NotificationState_ProviderData_PagerDuty)
	CompareWith(*Notification_State_NotificationState_ProviderData_PagerDuty) (cmp int, comparable bool)
}

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

func MustParseNotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue(pathStr, valueStr string) NotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue {
	fpv, err := ParseNotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathValue struct {
	NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath
	value interface{}
}

var _ NotificationStateNotificationStateProviderDataPagerDuty_FieldPathValue = (*NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object PagerDuty
func (fpv *NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathValue) SetTo(target **Notification_State_NotificationState_ProviderData_PagerDuty) {
	if *target == nil {
		*target = new(Notification_State_NotificationState_ProviderData_PagerDuty)
	}
	switch fpv.selector {
	case NotificationStateNotificationStateProviderDataPagerDuty_FieldPathSelectorIncidentKey:
		(*target).IncidentKey = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Notification_State_NotificationState_ProviderData_PagerDuty: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseNotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayItemValue(pathStr, valueStr string) NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathArrayItemValue struct {
	NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath
	value interface{}
}

var _ NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayItemValue = (*NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathArrayItemValue) GetSingle(source *Notification_State_NotificationState_ProviderData_PagerDuty) (interface{}, bool) {
	return nil, false
}

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

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

// NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayOfValues allows storing slice of values for PagerDuty fields according to their type
type NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationStateNotificationStateProviderDataPagerDuty_FieldPath
}

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

func MustParseNotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathArrayOfValues struct {
	NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPath
	values interface{}
}

var _ NotificationStateNotificationStateProviderDataPagerDuty_FieldPathArrayOfValues = (*NotificationStateNotificationStateProviderDataPagerDuty_FieldTerminalPathArrayOfValues)(nil)

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