github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/resources/v1/notifications/notification_msg.pb.fieldpath.go

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

package notification_msg

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

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

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

// proto imports
import (
	alert "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/alert"
	rcommon "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/common"
	log_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/log_condition"
	policy "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/policy"
	ts_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/ts_condition"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

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

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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &alert.Alert{}
	_ = &log_condition.LogCondition{}
	_ = &policy.Policy{}
	_ = &rcommon.LogCndSpec{}
	_ = &ts_condition.TsCondition{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &durationpb.Duration{}
	_ = &timestamppb.Timestamp{}
)

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

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

type NotificationMsg_FieldPathSelector int32

const (
	NotificationMsg_FieldPathSelectorProjectFqn                                 NotificationMsg_FieldPathSelector = 0
	NotificationMsg_FieldPathSelectorProjectDisplayName                         NotificationMsg_FieldPathSelector = 1
	NotificationMsg_FieldPathSelectorOrganizationFqn                            NotificationMsg_FieldPathSelector = 2
	NotificationMsg_FieldPathSelectorOrganizationDisplayName                    NotificationMsg_FieldPathSelector = 3
	NotificationMsg_FieldPathSelectorPolicyFqn                                  NotificationMsg_FieldPathSelector = 4
	NotificationMsg_FieldPathSelectorPolicyDisplayName                          NotificationMsg_FieldPathSelector = 5
	NotificationMsg_FieldPathSelectorNewFiringAlerts                            NotificationMsg_FieldPathSelector = 6
	NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator              NotificationMsg_FieldPathSelector = 7
	NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation NotificationMsg_FieldPathSelector = 8
	NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi                  NotificationMsg_FieldPathSelector = 9
	NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi  NotificationMsg_FieldPathSelector = 10
	NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied             NotificationMsg_FieldPathSelector = 11
	NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied       NotificationMsg_FieldPathSelector = 12
	NotificationMsg_FieldPathSelectorStoppedAlerts                              NotificationMsg_FieldPathSelector = 13
)

func (s NotificationMsg_FieldPathSelector) String() string {
	switch s {
	case NotificationMsg_FieldPathSelectorProjectFqn:
		return "project_fqn"
	case NotificationMsg_FieldPathSelectorProjectDisplayName:
		return "project_display_name"
	case NotificationMsg_FieldPathSelectorOrganizationFqn:
		return "organization_fqn"
	case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
		return "organization_display_name"
	case NotificationMsg_FieldPathSelectorPolicyFqn:
		return "policy_fqn"
	case NotificationMsg_FieldPathSelectorPolicyDisplayName:
		return "policy_display_name"
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		return "new_firing_alerts"
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		return "alerts_escalated_by_ai_to_operator"
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		return "alerts_awaiting_for_approval_with_ai_remediation"
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		return "alerts_flagged_to_ignore_by_ai"
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		return "alerts_with_condition_marked_for_adjusting_by_ai"
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		return "alerts_with_ai_remediation_applied"
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		return "alerts_with_operator_remediation_applied"
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		return "stopped_alerts"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", s))
	}
}

func BuildNotificationMsg_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsg_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "project_fqn", "projectFqn", "project-fqn":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorProjectFqn}, nil
		case "project_display_name", "projectDisplayName", "project-display-name":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorProjectDisplayName}, nil
		case "organization_fqn", "organizationFqn", "organization-fqn":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorOrganizationFqn}, nil
		case "organization_display_name", "organizationDisplayName", "organization-display-name":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorOrganizationDisplayName}, nil
		case "policy_fqn", "policyFqn", "policy-fqn":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorPolicyFqn}, nil
		case "policy_display_name", "policyDisplayName", "policy-display-name":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorPolicyDisplayName}, nil
		case "new_firing_alerts", "newFiringAlerts", "new-firing-alerts":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorNewFiringAlerts}, nil
		case "alerts_escalated_by_ai_to_operator", "alertsEscalatedByAiToOperator", "alerts-escalated-by-ai-to-operator":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator}, nil
		case "alerts_awaiting_for_approval_with_ai_remediation", "alertsAwaitingForApprovalWithAiRemediation", "alerts-awaiting-for-approval-with-ai-remediation":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation}, nil
		case "alerts_flagged_to_ignore_by_ai", "alertsFlaggedToIgnoreByAi", "alerts-flagged-to-ignore-by-ai":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi}, nil
		case "alerts_with_condition_marked_for_adjusting_by_ai", "alertsWithConditionMarkedForAdjustingByAi", "alerts-with-condition-marked-for-adjusting-by-ai":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi}, nil
		case "alerts_with_ai_remediation_applied", "alertsWithAiRemediationApplied", "alerts-with-ai-remediation-applied":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied}, nil
		case "alerts_with_operator_remediation_applied", "alertsWithOperatorRemediationApplied", "alerts-with-operator-remediation-applied":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied}, nil
		case "stopped_alerts", "stoppedAlerts", "stopped-alerts":
			return &NotificationMsg_FieldTerminalPath{selector: NotificationMsg_FieldPathSelectorStoppedAlerts}, nil
		}
	} else {
		switch fp[0] {
		case "new_firing_alerts", "newFiringAlerts", "new-firing-alerts":
			if subpath, err := BuildNotificationMsgAlertsGroup_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorNewFiringAlerts, subPath: subpath}, nil
			}
		case "alerts_escalated_by_ai_to_operator", "alertsEscalatedByAiToOperator", "alerts-escalated-by-ai-to-operator":
			if subpath, err := BuildNotificationMsgAlertsGroup_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator, subPath: subpath}, nil
			}
		case "alerts_awaiting_for_approval_with_ai_remediation", "alertsAwaitingForApprovalWithAiRemediation", "alerts-awaiting-for-approval-with-ai-remediation":
			if subpath, err := BuildNotificationMsgAlertsGroup_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation, subPath: subpath}, nil
			}
		case "alerts_flagged_to_ignore_by_ai", "alertsFlaggedToIgnoreByAi", "alerts-flagged-to-ignore-by-ai":
			if subpath, err := BuildNotificationMsgAlertsGroup_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi, subPath: subpath}, nil
			}
		case "alerts_with_condition_marked_for_adjusting_by_ai", "alertsWithConditionMarkedForAdjustingByAi", "alerts-with-condition-marked-for-adjusting-by-ai":
			if subpath, err := BuildNotificationMsgAlertsGroup_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi, subPath: subpath}, nil
			}
		case "alerts_with_ai_remediation_applied", "alertsWithAiRemediationApplied", "alerts-with-ai-remediation-applied":
			if subpath, err := BuildNotificationMsgAlertsGroup_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied, subPath: subpath}, nil
			}
		case "alerts_with_operator_remediation_applied", "alertsWithOperatorRemediationApplied", "alerts-with-operator-remediation-applied":
			if subpath, err := BuildNotificationMsgAlertsGroup_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied, subPath: subpath}, nil
			}
		case "stopped_alerts", "stoppedAlerts", "stopped-alerts":
			if subpath, err := BuildNotificationMsgAlertsGroup_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsg_FieldSubPath{selector: NotificationMsg_FieldPathSelectorStoppedAlerts, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg", fp)
}

func ParseNotificationMsg_FieldPath(rawField string) (NotificationMsg_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsg_FieldPath(fp)
}

func MustParseNotificationMsg_FieldPath(rawField string) NotificationMsg_FieldPath {
	fp, err := ParseNotificationMsg_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsg_FieldTerminalPath struct {
	selector NotificationMsg_FieldPathSelector
}

var _ NotificationMsg_FieldPath = (*NotificationMsg_FieldTerminalPath)(nil)

func (fp *NotificationMsg_FieldTerminalPath) Selector() NotificationMsg_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationMsg
func (fp *NotificationMsg_FieldTerminalPath) Get(source *NotificationMsg) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationMsg_FieldPathSelectorProjectFqn:
			if source.ProjectFqn != nil {
				values = append(values, source.ProjectFqn)
			}
		case NotificationMsg_FieldPathSelectorProjectDisplayName:
			values = append(values, source.ProjectDisplayName)
		case NotificationMsg_FieldPathSelectorOrganizationFqn:
			if source.OrganizationFqn != nil {
				values = append(values, source.OrganizationFqn)
			}
		case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
			values = append(values, source.OrganizationDisplayName)
		case NotificationMsg_FieldPathSelectorPolicyFqn:
			if source.PolicyFqn != nil {
				values = append(values, source.PolicyFqn)
			}
		case NotificationMsg_FieldPathSelectorPolicyDisplayName:
			values = append(values, source.PolicyDisplayName)
		case NotificationMsg_FieldPathSelectorNewFiringAlerts:
			if source.NewFiringAlerts != nil {
				values = append(values, source.NewFiringAlerts)
			}
		case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
			if source.AlertsEscalatedByAiToOperator != nil {
				values = append(values, source.AlertsEscalatedByAiToOperator)
			}
		case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
			if source.AlertsAwaitingForApprovalWithAiRemediation != nil {
				values = append(values, source.AlertsAwaitingForApprovalWithAiRemediation)
			}
		case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
			if source.AlertsFlaggedToIgnoreByAi != nil {
				values = append(values, source.AlertsFlaggedToIgnoreByAi)
			}
		case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
			if source.AlertsWithConditionMarkedForAdjustingByAi != nil {
				values = append(values, source.AlertsWithConditionMarkedForAdjustingByAi)
			}
		case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
			if source.AlertsWithAiRemediationApplied != nil {
				values = append(values, source.AlertsWithAiRemediationApplied)
			}
		case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
			if source.AlertsWithOperatorRemediationApplied != nil {
				values = append(values, source.AlertsWithOperatorRemediationApplied)
			}
		case NotificationMsg_FieldPathSelectorStoppedAlerts:
			if source.StoppedAlerts != nil {
				values = append(values, source.StoppedAlerts)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationMsg
func (fp *NotificationMsg_FieldTerminalPath) GetSingle(source *NotificationMsg) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsg_FieldPathSelectorProjectFqn:
		res := source.GetProjectFqn()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorProjectDisplayName:
		return source.GetProjectDisplayName(), source != nil
	case NotificationMsg_FieldPathSelectorOrganizationFqn:
		res := source.GetOrganizationFqn()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
		return source.GetOrganizationDisplayName(), source != nil
	case NotificationMsg_FieldPathSelectorPolicyFqn:
		res := source.GetPolicyFqn()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorPolicyDisplayName:
		return source.GetPolicyDisplayName(), source != nil
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		res := source.GetNewFiringAlerts()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		res := source.GetAlertsEscalatedByAiToOperator()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		res := source.GetAlertsAwaitingForApprovalWithAiRemediation()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		res := source.GetAlertsFlaggedToIgnoreByAi()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		res := source.GetAlertsWithConditionMarkedForAdjustingByAi()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		res := source.GetAlertsWithAiRemediationApplied()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		res := source.GetAlertsWithOperatorRemediationApplied()
		return res, res != nil
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		res := source.GetStoppedAlerts()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsg_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsg_FieldPathSelectorProjectFqn:
		return (*iam_project.Name)(nil)
	case NotificationMsg_FieldPathSelectorProjectDisplayName:
		return ""
	case NotificationMsg_FieldPathSelectorOrganizationFqn:
		return (*iam_organization.Name)(nil)
	case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
		return ""
	case NotificationMsg_FieldPathSelectorPolicyFqn:
		return (*policy.Name)(nil)
	case NotificationMsg_FieldPathSelectorPolicyDisplayName:
		return ""
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		return (*NotificationMsg_AlertsGroup)(nil)
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		return (*NotificationMsg_AlertsGroup)(nil)
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		return (*NotificationMsg_AlertsGroup)(nil)
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		return (*NotificationMsg_AlertsGroup)(nil)
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		return (*NotificationMsg_AlertsGroup)(nil)
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		return (*NotificationMsg_AlertsGroup)(nil)
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		return (*NotificationMsg_AlertsGroup)(nil)
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		return (*NotificationMsg_AlertsGroup)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fp.selector))
	}
}

func (fp *NotificationMsg_FieldTerminalPath) ClearValue(item *NotificationMsg) {
	if item != nil {
		switch fp.selector {
		case NotificationMsg_FieldPathSelectorProjectFqn:
			item.ProjectFqn = nil
		case NotificationMsg_FieldPathSelectorProjectDisplayName:
			item.ProjectDisplayName = ""
		case NotificationMsg_FieldPathSelectorOrganizationFqn:
			item.OrganizationFqn = nil
		case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
			item.OrganizationDisplayName = ""
		case NotificationMsg_FieldPathSelectorPolicyFqn:
			item.PolicyFqn = nil
		case NotificationMsg_FieldPathSelectorPolicyDisplayName:
			item.PolicyDisplayName = ""
		case NotificationMsg_FieldPathSelectorNewFiringAlerts:
			item.NewFiringAlerts = nil
		case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
			item.AlertsEscalatedByAiToOperator = nil
		case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
			item.AlertsAwaitingForApprovalWithAiRemediation = nil
		case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
			item.AlertsFlaggedToIgnoreByAi = nil
		case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
			item.AlertsWithConditionMarkedForAdjustingByAi = nil
		case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
			item.AlertsWithAiRemediationApplied = nil
		case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
			item.AlertsWithOperatorRemediationApplied = nil
		case NotificationMsg_FieldPathSelectorStoppedAlerts:
			item.StoppedAlerts = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsg_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsg_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsg_FieldPathSelectorProjectFqn ||
		fp.selector == NotificationMsg_FieldPathSelectorProjectDisplayName ||
		fp.selector == NotificationMsg_FieldPathSelectorOrganizationFqn ||
		fp.selector == NotificationMsg_FieldPathSelectorOrganizationDisplayName ||
		fp.selector == NotificationMsg_FieldPathSelectorPolicyFqn ||
		fp.selector == NotificationMsg_FieldPathSelectorPolicyDisplayName
}

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

func (fp *NotificationMsg_FieldTerminalPath) WithIValue(value interface{}) NotificationMsg_FieldPathValue {
	switch fp.selector {
	case NotificationMsg_FieldPathSelectorProjectFqn:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*iam_project.Name)}
	case NotificationMsg_FieldPathSelectorProjectDisplayName:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsg_FieldPathSelectorOrganizationFqn:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*iam_organization.Name)}
	case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsg_FieldPathSelectorPolicyFqn:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*policy.Name)}
	case NotificationMsg_FieldPathSelectorPolicyDisplayName:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		return &NotificationMsg_FieldTerminalPathValue{NotificationMsg_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fp.selector))
	}
}

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

func (fp *NotificationMsg_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsg_FieldPathArrayOfValues {
	fpaov := &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsg_FieldPathSelectorProjectFqn:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*iam_project.Name)}
	case NotificationMsg_FieldPathSelectorProjectDisplayName:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsg_FieldPathSelectorOrganizationFqn:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*iam_organization.Name)}
	case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsg_FieldPathSelectorPolicyFqn:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*policy.Name)}
	case NotificationMsg_FieldPathSelectorPolicyDisplayName:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup)}
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		return &NotificationMsg_FieldTerminalPathArrayOfValues{NotificationMsg_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type NotificationMsg_FieldSubPath struct {
	selector NotificationMsg_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsg_FieldPath = (*NotificationMsg_FieldSubPath)(nil)

func (fps *NotificationMsg_FieldSubPath) Selector() NotificationMsg_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsg_FieldSubPath) AsNewFiringAlertsSubPath() (NotificationMsgAlertsGroup_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroup_FieldPath)
	return res, ok
}
func (fps *NotificationMsg_FieldSubPath) AsAlertsEscalatedByAiToOperatorSubPath() (NotificationMsgAlertsGroup_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroup_FieldPath)
	return res, ok
}
func (fps *NotificationMsg_FieldSubPath) AsAlertsAwaitingForApprovalWithAiRemediationSubPath() (NotificationMsgAlertsGroup_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroup_FieldPath)
	return res, ok
}
func (fps *NotificationMsg_FieldSubPath) AsAlertsFlaggedToIgnoreByAiSubPath() (NotificationMsgAlertsGroup_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroup_FieldPath)
	return res, ok
}
func (fps *NotificationMsg_FieldSubPath) AsAlertsWithConditionMarkedForAdjustingByAiSubPath() (NotificationMsgAlertsGroup_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroup_FieldPath)
	return res, ok
}
func (fps *NotificationMsg_FieldSubPath) AsAlertsWithAiRemediationAppliedSubPath() (NotificationMsgAlertsGroup_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroup_FieldPath)
	return res, ok
}
func (fps *NotificationMsg_FieldSubPath) AsAlertsWithOperatorRemediationAppliedSubPath() (NotificationMsgAlertsGroup_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroup_FieldPath)
	return res, ok
}
func (fps *NotificationMsg_FieldSubPath) AsStoppedAlertsSubPath() (NotificationMsgAlertsGroup_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroup_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source NotificationMsg
func (fps *NotificationMsg_FieldSubPath) Get(source *NotificationMsg) (values []interface{}) {
	switch fps.selector {
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		values = append(values, fps.subPath.GetRaw(source.GetNewFiringAlerts())...)
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		values = append(values, fps.subPath.GetRaw(source.GetAlertsEscalatedByAiToOperator())...)
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		values = append(values, fps.subPath.GetRaw(source.GetAlertsAwaitingForApprovalWithAiRemediation())...)
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		values = append(values, fps.subPath.GetRaw(source.GetAlertsFlaggedToIgnoreByAi())...)
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		values = append(values, fps.subPath.GetRaw(source.GetAlertsWithConditionMarkedForAdjustingByAi())...)
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		values = append(values, fps.subPath.GetRaw(source.GetAlertsWithAiRemediationApplied())...)
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		values = append(values, fps.subPath.GetRaw(source.GetAlertsWithOperatorRemediationApplied())...)
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		values = append(values, fps.subPath.GetRaw(source.GetStoppedAlerts())...)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source NotificationMsg
func (fps *NotificationMsg_FieldSubPath) GetSingle(source *NotificationMsg) (interface{}, bool) {
	switch fps.selector {
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		if source.GetNewFiringAlerts() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetNewFiringAlerts())
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		if source.GetAlertsEscalatedByAiToOperator() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAlertsEscalatedByAiToOperator())
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		if source.GetAlertsAwaitingForApprovalWithAiRemediation() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAlertsAwaitingForApprovalWithAiRemediation())
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		if source.GetAlertsFlaggedToIgnoreByAi() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAlertsFlaggedToIgnoreByAi())
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		if source.GetAlertsWithConditionMarkedForAdjustingByAi() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAlertsWithConditionMarkedForAdjustingByAi())
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		if source.GetAlertsWithAiRemediationApplied() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAlertsWithAiRemediationApplied())
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		if source.GetAlertsWithOperatorRemediationApplied() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAlertsWithOperatorRemediationApplied())
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		if source.GetStoppedAlerts() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetStoppedAlerts())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fps.selector))
	}
}

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

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

func (fps *NotificationMsg_FieldSubPath) ClearValue(item *NotificationMsg) {
	if item != nil {
		switch fps.selector {
		case NotificationMsg_FieldPathSelectorNewFiringAlerts:
			fps.subPath.ClearValueRaw(item.NewFiringAlerts)
		case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
			fps.subPath.ClearValueRaw(item.AlertsEscalatedByAiToOperator)
		case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
			fps.subPath.ClearValueRaw(item.AlertsAwaitingForApprovalWithAiRemediation)
		case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
			fps.subPath.ClearValueRaw(item.AlertsFlaggedToIgnoreByAi)
		case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
			fps.subPath.ClearValueRaw(item.AlertsWithConditionMarkedForAdjustingByAi)
		case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
			fps.subPath.ClearValueRaw(item.AlertsWithAiRemediationApplied)
		case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
			fps.subPath.ClearValueRaw(item.AlertsWithOperatorRemediationApplied)
		case NotificationMsg_FieldPathSelectorStoppedAlerts:
			fps.subPath.ClearValueRaw(item.StoppedAlerts)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fps.selector))
		}
	}
}

func (fps *NotificationMsg_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg))
}

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

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

func (fps *NotificationMsg_FieldSubPath) WithIValue(value interface{}) NotificationMsg_FieldPathValue {
	return &NotificationMsg_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsg_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsg_FieldPathArrayOfValues {
	return &NotificationMsg_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsg_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsg_FieldPathArrayItemValue {
	return &NotificationMsg_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseNotificationMsg_FieldPathValue(pathStr, valueStr string) NotificationMsg_FieldPathValue {
	fpv, err := ParseNotificationMsg_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsg_FieldTerminalPathValue struct {
	NotificationMsg_FieldTerminalPath
	value interface{}
}

var _ NotificationMsg_FieldPathValue = (*NotificationMsg_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'NotificationMsg' as interface{}
func (fpv *NotificationMsg_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsProjectFqnValue() (*iam_project.Name, bool) {
	res, ok := fpv.value.(*iam_project.Name)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsProjectDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsOrganizationFqnValue() (*iam_organization.Name, bool) {
	res, ok := fpv.value.(*iam_organization.Name)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsOrganizationDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsPolicyFqnValue() (*policy.Name, bool) {
	res, ok := fpv.value.(*policy.Name)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsPolicyDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsNewFiringAlertsValue() (*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsAlertsEscalatedByAiToOperatorValue() (*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsAlertsAwaitingForApprovalWithAiRemediationValue() (*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsAlertsFlaggedToIgnoreByAiValue() (*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsAlertsWithConditionMarkedForAdjustingByAiValue() (*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsAlertsWithAiRemediationAppliedValue() (*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsAlertsWithOperatorRemediationAppliedValue() (*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpv *NotificationMsg_FieldTerminalPathValue) AsStoppedAlertsValue() (*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup)
	return res, ok
}

// SetTo stores value for selected field for object NotificationMsg
func (fpv *NotificationMsg_FieldTerminalPathValue) SetTo(target **NotificationMsg) {
	if *target == nil {
		*target = new(NotificationMsg)
	}
	switch fpv.selector {
	case NotificationMsg_FieldPathSelectorProjectFqn:
		(*target).ProjectFqn = fpv.value.(*iam_project.Name)
	case NotificationMsg_FieldPathSelectorProjectDisplayName:
		(*target).ProjectDisplayName = fpv.value.(string)
	case NotificationMsg_FieldPathSelectorOrganizationFqn:
		(*target).OrganizationFqn = fpv.value.(*iam_organization.Name)
	case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
		(*target).OrganizationDisplayName = fpv.value.(string)
	case NotificationMsg_FieldPathSelectorPolicyFqn:
		(*target).PolicyFqn = fpv.value.(*policy.Name)
	case NotificationMsg_FieldPathSelectorPolicyDisplayName:
		(*target).PolicyDisplayName = fpv.value.(string)
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		(*target).NewFiringAlerts = fpv.value.(*NotificationMsg_AlertsGroup)
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		(*target).AlertsEscalatedByAiToOperator = fpv.value.(*NotificationMsg_AlertsGroup)
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		(*target).AlertsAwaitingForApprovalWithAiRemediation = fpv.value.(*NotificationMsg_AlertsGroup)
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		(*target).AlertsFlaggedToIgnoreByAi = fpv.value.(*NotificationMsg_AlertsGroup)
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		(*target).AlertsWithConditionMarkedForAdjustingByAi = fpv.value.(*NotificationMsg_AlertsGroup)
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		(*target).AlertsWithAiRemediationApplied = fpv.value.(*NotificationMsg_AlertsGroup)
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		(*target).AlertsWithOperatorRemediationApplied = fpv.value.(*NotificationMsg_AlertsGroup)
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		(*target).StoppedAlerts = fpv.value.(*NotificationMsg_AlertsGroup)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationMsg_FieldTerminalPathValue' with the value under path in 'NotificationMsg'.
func (fpv *NotificationMsg_FieldTerminalPathValue) CompareWith(source *NotificationMsg) (int, bool) {
	switch fpv.selector {
	case NotificationMsg_FieldPathSelectorProjectFqn:
		leftValue := fpv.value.(*iam_project.Name)
		rightValue := source.GetProjectFqn()
		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 NotificationMsg_FieldPathSelectorProjectDisplayName:
		leftValue := fpv.value.(string)
		rightValue := source.GetProjectDisplayName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsg_FieldPathSelectorOrganizationFqn:
		leftValue := fpv.value.(*iam_organization.Name)
		rightValue := source.GetOrganizationFqn()
		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 NotificationMsg_FieldPathSelectorOrganizationDisplayName:
		leftValue := fpv.value.(string)
		rightValue := source.GetOrganizationDisplayName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsg_FieldPathSelectorPolicyFqn:
		leftValue := fpv.value.(*policy.Name)
		rightValue := source.GetPolicyFqn()
		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 NotificationMsg_FieldPathSelectorPolicyDisplayName:
		leftValue := fpv.value.(string)
		rightValue := source.GetPolicyDisplayName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		return 0, false
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		return 0, false
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		return 0, false
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		return 0, false
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		return 0, false
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		return 0, false
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		return 0, false
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fpv.selector))
	}
}

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

type NotificationMsg_FieldSubPathValue struct {
	NotificationMsg_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsg_FieldPathValue = (*NotificationMsg_FieldSubPathValue)(nil)

func (fpvs *NotificationMsg_FieldSubPathValue) AsNewFiringAlertsPathValue() (NotificationMsgAlertsGroup_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsg_FieldSubPathValue) AsAlertsEscalatedByAiToOperatorPathValue() (NotificationMsgAlertsGroup_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsg_FieldSubPathValue) AsAlertsAwaitingForApprovalWithAiRemediationPathValue() (NotificationMsgAlertsGroup_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsg_FieldSubPathValue) AsAlertsFlaggedToIgnoreByAiPathValue() (NotificationMsgAlertsGroup_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsg_FieldSubPathValue) AsAlertsWithConditionMarkedForAdjustingByAiPathValue() (NotificationMsgAlertsGroup_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsg_FieldSubPathValue) AsAlertsWithAiRemediationAppliedPathValue() (NotificationMsgAlertsGroup_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsg_FieldSubPathValue) AsAlertsWithOperatorRemediationAppliedPathValue() (NotificationMsgAlertsGroup_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsg_FieldSubPathValue) AsStoppedAlertsPathValue() (NotificationMsgAlertsGroup_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationMsg_FieldSubPathValue) SetTo(target **NotificationMsg) {
	if *target == nil {
		*target = new(NotificationMsg)
	}
	switch fpvs.Selector() {
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).SetTo(&(*target).NewFiringAlerts)
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).SetTo(&(*target).AlertsEscalatedByAiToOperator)
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).SetTo(&(*target).AlertsAwaitingForApprovalWithAiRemediation)
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).SetTo(&(*target).AlertsFlaggedToIgnoreByAi)
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).SetTo(&(*target).AlertsWithConditionMarkedForAdjustingByAi)
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).SetTo(&(*target).AlertsWithAiRemediationApplied)
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).SetTo(&(*target).AlertsWithOperatorRemediationApplied)
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).SetTo(&(*target).StoppedAlerts)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationMsg_FieldSubPathValue) CompareWith(source *NotificationMsg) (int, bool) {
	switch fpvs.Selector() {
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		return fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).CompareWith(source.GetNewFiringAlerts())
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		return fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).CompareWith(source.GetAlertsEscalatedByAiToOperator())
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		return fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).CompareWith(source.GetAlertsAwaitingForApprovalWithAiRemediation())
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		return fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).CompareWith(source.GetAlertsFlaggedToIgnoreByAi())
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		return fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).CompareWith(source.GetAlertsWithConditionMarkedForAdjustingByAi())
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		return fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).CompareWith(source.GetAlertsWithAiRemediationApplied())
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		return fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).CompareWith(source.GetAlertsWithOperatorRemediationApplied())
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		return fpvs.subPathValue.(NotificationMsgAlertsGroup_FieldPathValue).CompareWith(source.GetStoppedAlerts())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationMsg_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsg_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsg_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsg_FieldTerminalPathArrayItemValue struct {
	NotificationMsg_FieldTerminalPath
	value interface{}
}

var _ NotificationMsg_FieldPathArrayItemValue = (*NotificationMsg_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationMsg_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) AsNewFiringAlertsPathItemValue() (NotificationMsgAlertsGroup_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) AsAlertsEscalatedByAiToOperatorPathItemValue() (NotificationMsgAlertsGroup_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) AsAlertsAwaitingForApprovalWithAiRemediationPathItemValue() (NotificationMsgAlertsGroup_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) AsAlertsFlaggedToIgnoreByAiPathItemValue() (NotificationMsgAlertsGroup_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) AsAlertsWithConditionMarkedForAdjustingByAiPathItemValue() (NotificationMsgAlertsGroup_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) AsAlertsWithAiRemediationAppliedPathItemValue() (NotificationMsgAlertsGroup_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) AsAlertsWithOperatorRemediationAppliedPathItemValue() (NotificationMsgAlertsGroup_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) AsStoppedAlertsPathItemValue() (NotificationMsgAlertsGroup_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'NotificationMsg'
func (fpaivs *NotificationMsg_FieldSubPathArrayItemValue) ContainsValue(source *NotificationMsg) bool {
	switch fpaivs.Selector() {
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue).ContainsValue(source.GetNewFiringAlerts())
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue).ContainsValue(source.GetAlertsEscalatedByAiToOperator())
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue).ContainsValue(source.GetAlertsAwaitingForApprovalWithAiRemediation())
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue).ContainsValue(source.GetAlertsFlaggedToIgnoreByAi())
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue).ContainsValue(source.GetAlertsWithConditionMarkedForAdjustingByAi())
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue).ContainsValue(source.GetAlertsWithAiRemediationApplied())
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue).ContainsValue(source.GetAlertsWithOperatorRemediationApplied())
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroup_FieldPathArrayItemValue).ContainsValue(source.GetStoppedAlerts())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg: %d", fpaivs.Selector()))
	}
}

// NotificationMsg_FieldPathArrayOfValues allows storing slice of values for NotificationMsg fields according to their type
type NotificationMsg_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsg_FieldPath
}

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

func MustParseNotificationMsg_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsg_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsg_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsg_FieldTerminalPathArrayOfValues struct {
	NotificationMsg_FieldTerminalPath
	values interface{}
}

var _ NotificationMsg_FieldPathArrayOfValues = (*NotificationMsg_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsg_FieldPathSelectorProjectFqn:
		for _, v := range fpaov.values.([]*iam_project.Name) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorProjectDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorOrganizationFqn:
		for _, v := range fpaov.values.([]*iam_organization.Name) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorOrganizationDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorPolicyFqn:
		for _, v := range fpaov.values.([]*policy.Name) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorPolicyDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorNewFiringAlerts:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorAlertsEscalatedByAiToOperator:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorAlertsAwaitingForApprovalWithAiRemediation:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorAlertsFlaggedToIgnoreByAi:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorAlertsWithConditionMarkedForAdjustingByAi:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorAlertsWithAiRemediationApplied:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorAlertsWithOperatorRemediationApplied:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup) {
			values = append(values, v)
		}
	case NotificationMsg_FieldPathSelectorStoppedAlerts:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsProjectFqnArrayOfValues() ([]*iam_project.Name, bool) {
	res, ok := fpaov.values.([]*iam_project.Name)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsProjectDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsOrganizationFqnArrayOfValues() ([]*iam_organization.Name, bool) {
	res, ok := fpaov.values.([]*iam_organization.Name)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsOrganizationDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsPolicyFqnArrayOfValues() ([]*policy.Name, bool) {
	res, ok := fpaov.values.([]*policy.Name)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsPolicyDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsNewFiringAlertsArrayOfValues() ([]*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsAlertsEscalatedByAiToOperatorArrayOfValues() ([]*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsAlertsAwaitingForApprovalWithAiRemediationArrayOfValues() ([]*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsAlertsFlaggedToIgnoreByAiArrayOfValues() ([]*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsAlertsWithConditionMarkedForAdjustingByAiArrayOfValues() ([]*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsAlertsWithAiRemediationAppliedArrayOfValues() ([]*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsAlertsWithOperatorRemediationAppliedArrayOfValues() ([]*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup)
	return res, ok
}
func (fpaov *NotificationMsg_FieldTerminalPathArrayOfValues) AsStoppedAlertsArrayOfValues() ([]*NotificationMsg_AlertsGroup, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup)
	return res, ok
}

type NotificationMsg_FieldSubPathArrayOfValues struct {
	NotificationMsg_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsg_FieldPathArrayOfValues = (*NotificationMsg_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsg_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsg_FieldSubPathArrayOfValues) AsNewFiringAlertsPathArrayOfValues() (NotificationMsgAlertsGroup_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroup_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsg_FieldSubPathArrayOfValues) AsAlertsEscalatedByAiToOperatorPathArrayOfValues() (NotificationMsgAlertsGroup_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroup_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsg_FieldSubPathArrayOfValues) AsAlertsAwaitingForApprovalWithAiRemediationPathArrayOfValues() (NotificationMsgAlertsGroup_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroup_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsg_FieldSubPathArrayOfValues) AsAlertsFlaggedToIgnoreByAiPathArrayOfValues() (NotificationMsgAlertsGroup_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroup_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsg_FieldSubPathArrayOfValues) AsAlertsWithConditionMarkedForAdjustingByAiPathArrayOfValues() (NotificationMsgAlertsGroup_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroup_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsg_FieldSubPathArrayOfValues) AsAlertsWithAiRemediationAppliedPathArrayOfValues() (NotificationMsgAlertsGroup_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroup_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsg_FieldSubPathArrayOfValues) AsAlertsWithOperatorRemediationAppliedPathArrayOfValues() (NotificationMsgAlertsGroup_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroup_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsg_FieldSubPathArrayOfValues) AsStoppedAlertsPathArrayOfValues() (NotificationMsgAlertsGroup_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroup_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationMsgAlertsGroup_FieldPathSelector int32

const (
	NotificationMsgAlertsGroup_FieldPathSelectorByCondition NotificationMsgAlertsGroup_FieldPathSelector = 0
)

func (s NotificationMsgAlertsGroup_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroup_FieldPathSelectorByCondition:
		return "by_condition"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup: %d", s))
	}
}

func BuildNotificationMsgAlertsGroup_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroup_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "by_condition", "byCondition", "by-condition":
			return &NotificationMsgAlertsGroup_FieldTerminalPath{selector: NotificationMsgAlertsGroup_FieldPathSelectorByCondition}, nil
		}
	} else {
		switch fp[0] {
		case "by_condition", "byCondition", "by-condition":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlerts_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroup_FieldSubPath{selector: NotificationMsgAlertsGroup_FieldPathSelectorByCondition, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup", fp)
}

func ParseNotificationMsgAlertsGroup_FieldPath(rawField string) (NotificationMsgAlertsGroup_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroup_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroup_FieldPath(rawField string) NotificationMsgAlertsGroup_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroup_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroup_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroup_FieldPathSelector
}

var _ NotificationMsgAlertsGroup_FieldPath = (*NotificationMsgAlertsGroup_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroup_FieldTerminalPath) Selector() NotificationMsgAlertsGroup_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *NotificationMsgAlertsGroup_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroup_FieldPathSelectorByCondition:
			item.ByCondition = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroup_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup))
}

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

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

func (fp *NotificationMsgAlertsGroup_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroup_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroup_FieldPathSelectorByCondition:
		return &NotificationMsgAlertsGroup_FieldTerminalPathValue{NotificationMsgAlertsGroup_FieldTerminalPath: *fp, value: value.([]*NotificationMsg_AlertsGroup_ConditionAlerts)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroup_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroup_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroup_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroup_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroup_FieldPathSelectorByCondition:
		return &NotificationMsgAlertsGroup_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroup_FieldTerminalPath: *fp, values: values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *NotificationMsgAlertsGroup_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroup_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationMsgAlertsGroup_FieldPathSelectorByCondition:
		return &NotificationMsgAlertsGroup_FieldTerminalPathArrayItemValue{NotificationMsgAlertsGroup_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup: %d", fp.selector))
	}
}

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

type NotificationMsgAlertsGroup_FieldSubPath struct {
	selector NotificationMsgAlertsGroup_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsgAlertsGroup_FieldPath = (*NotificationMsgAlertsGroup_FieldSubPath)(nil)

func (fps *NotificationMsgAlertsGroup_FieldSubPath) Selector() NotificationMsgAlertsGroup_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsgAlertsGroup_FieldSubPath) AsByConditionSubPath() (NotificationMsgAlertsGroupConditionAlerts_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlerts_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *NotificationMsgAlertsGroup_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg_AlertsGroup))
}

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

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

func (fps *NotificationMsgAlertsGroup_FieldSubPath) WithIValue(value interface{}) NotificationMsgAlertsGroup_FieldPathValue {
	return &NotificationMsgAlertsGroup_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsgAlertsGroup_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroup_FieldPathArrayOfValues {
	return &NotificationMsgAlertsGroup_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsgAlertsGroup_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroup_FieldPathArrayItemValue {
	return &NotificationMsgAlertsGroup_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationMsgAlertsGroup_FieldPathValue allows storing values for AlertsGroup fields according to their type
type NotificationMsgAlertsGroup_FieldPathValue interface {
	NotificationMsgAlertsGroup_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup)
	CompareWith(*NotificationMsg_AlertsGroup) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroup_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroup_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroup_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroup_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroup_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroup_FieldPathValue = (*NotificationMsgAlertsGroup_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AlertsGroup' as interface{}
func (fpv *NotificationMsgAlertsGroup_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroup_FieldTerminalPathValue) AsByConditionValue() ([]*NotificationMsg_AlertsGroup_ConditionAlerts, bool) {
	res, ok := fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts)
	return res, ok
}

// SetTo stores value for selected field for object AlertsGroup
func (fpv *NotificationMsgAlertsGroup_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroup_FieldPathSelectorByCondition:
		(*target).ByCondition = fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup: %d", fpv.selector))
	}
}

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

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

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

type NotificationMsgAlertsGroup_FieldSubPathValue struct {
	NotificationMsgAlertsGroup_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsgAlertsGroup_FieldPathValue = (*NotificationMsgAlertsGroup_FieldSubPathValue)(nil)

func (fpvs *NotificationMsgAlertsGroup_FieldSubPathValue) AsByConditionPathValue() (NotificationMsgAlertsGroupConditionAlerts_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlerts_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseNotificationMsgAlertsGroup_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroup_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroup_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroup_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroup_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroup_FieldPathArrayItemValue = (*NotificationMsgAlertsGroup_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationMsg_AlertsGroup as interface{}
func (fpaiv *NotificationMsgAlertsGroup_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *NotificationMsgAlertsGroup_FieldTerminalPathArrayItemValue) AsByConditionItemValue() (*NotificationMsg_AlertsGroup_ConditionAlerts, bool) {
	res, ok := fpaiv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts)
	return res, ok
}

func (fpaiv *NotificationMsgAlertsGroup_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'AlertsGroup'
func (fpaiv *NotificationMsgAlertsGroup_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup) bool {
	slice := fpaiv.NotificationMsgAlertsGroup_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 NotificationMsgAlertsGroup_FieldSubPathArrayItemValue struct {
	NotificationMsgAlertsGroup_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// NotificationMsgAlertsGroup_FieldPathArrayOfValues allows storing slice of values for AlertsGroup fields according to their type
type NotificationMsgAlertsGroup_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroup_FieldPath
}

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

func MustParseNotificationMsgAlertsGroup_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroup_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroup_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroup_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroup_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroup_FieldPathArrayOfValues = (*NotificationMsgAlertsGroup_FieldTerminalPathArrayOfValues)(nil)

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

type NotificationMsgAlertsGroup_FieldSubPathArrayOfValues struct {
	NotificationMsgAlertsGroup_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsgAlertsGroup_FieldPathArrayOfValues = (*NotificationMsgAlertsGroup_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsgAlertsGroup_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsgAlertsGroup_FieldSubPathArrayOfValues) AsByConditionPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition        NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector = 1
	NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts              NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector = 2
	NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount     NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector = 3
)

func (s NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		return "time_series_condition"
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		return "log_condition"
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		return "alerts"
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
		return "more_alerts_count"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlerts_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlerts_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "time_series_condition", "timeSeriesCondition", "time-series-condition":
			return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition}, nil
		case "log_condition", "logCondition", "log-condition":
			return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition}, nil
		case "alerts":
			return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts}, nil
		case "more_alerts_count", "moreAlertsCount", "more-alerts-count":
			return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount}, nil
		}
	} else {
		switch fp[0] {
		case "time_series_condition", "timeSeriesCondition", "time-series-condition":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlerts_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition, subPath: subpath}, nil
			}
		case "log_condition", "logCondition", "log-condition":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlerts_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition, subPath: subpath}, nil
			}
		case "alerts":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsAlert_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlerts_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlerts_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlerts_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlerts_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlerts_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlerts_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlerts_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlerts_FieldPath = (*NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationMsg_AlertsGroup_ConditionAlerts
func (fp *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
			if source, ok := source.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); ok && source != nil {
				if source.TimeSeriesCondition != nil {
					values = append(values, source.TimeSeriesCondition)
				}
			}
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
			if source, ok := source.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); ok && source != nil {
				if source.LogCondition != nil {
					values = append(values, source.LogCondition)
				}
			}
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
			for _, value := range source.GetAlerts() {
				values = append(values, value)
			}
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
			values = append(values, source.MoreAlertsCount)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts
func (fp *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetTimeSeriesCondition(), false
		}
		_, oneOfSelected := source.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition)
		if !oneOfSelected {
			return source.GetTimeSeriesCondition(), false // to return "type" information
		}
		res := source.GetTimeSeriesCondition()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetLogCondition(), false
		}
		_, oneOfSelected := source.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition)
		if !oneOfSelected {
			return source.GetLogCondition(), false // to return "type" information
		}
		res := source.GetLogCondition()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		res := source.GetAlerts()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
		return source.GetMoreAlertsCount(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		return (*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType)(nil)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		return (*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType)(nil)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		return ([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert)(nil)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
			if item, ok := item.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); ok {
				item.TimeSeriesCondition = nil
			}
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
			if item, ok := item.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); ok {
				item.LogCondition = nil
			}
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
			item.Alerts = nil
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
			item.MoreAlertsCount = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts))
}

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

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

func (fp *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlerts_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType)}
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType)}
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp, value: value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert)}
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
		return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType)}
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType)}
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp, values: values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert)}
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
		return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		return &NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayItemValue{NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fp.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlerts_FieldSubPath struct {
	selector NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsgAlertsGroupConditionAlerts_FieldPath = (*NotificationMsgAlertsGroupConditionAlerts_FieldSubPath)(nil)

func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) Selector() NotificationMsgAlertsGroupConditionAlerts_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) AsTimeSeriesConditionSubPath() (NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath)
	return res, ok
}
func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) AsLogConditionSubPath() (NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath)
	return res, ok
}
func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) AsAlertsSubPath() (NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source NotificationMsg_AlertsGroup_ConditionAlerts
func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts) (values []interface{}) {
	switch fps.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		values = append(values, fps.subPath.GetRaw(source.GetTimeSeriesCondition())...)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		values = append(values, fps.subPath.GetRaw(source.GetLogCondition())...)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		for _, item := range source.GetAlerts() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source NotificationMsg_AlertsGroup_ConditionAlerts
func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts) (interface{}, bool) {
	switch fps.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		if source.GetTimeSeriesCondition() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetTimeSeriesCondition())
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		if source.GetLogCondition() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetLogCondition())
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		if len(source.GetAlerts()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAlerts()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fps.selector))
	}
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts) {
	if item != nil {
		switch fps.selector {
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
			if item.Type != nil {
				if item, ok := item.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); ok {
					fps.subPath.ClearValueRaw(item.TimeSeriesCondition)
				}
			}
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
			if item.Type != nil {
				if item, ok := item.Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); ok {
					fps.subPath.ClearValueRaw(item.LogCondition)
				}
			}
		case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
			for _, subItem := range item.Alerts {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fps.selector))
		}
	}
}

func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts))
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlerts_FieldPathValue {
	return &NotificationMsgAlertsGroupConditionAlerts_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues {
	return &NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlerts_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayItemValue {
	return &NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationMsgAlertsGroupConditionAlerts_FieldPathValue allows storing values for ConditionAlerts fields according to their type
type NotificationMsgAlertsGroupConditionAlerts_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlerts_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlerts_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlerts_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlerts_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlerts_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ConditionAlerts' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue) AsTimeSeriesConditionValue() (*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue) AsLogConditionValue() (*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue) AsAlertsValue() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert, bool) {
	res, ok := fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue) AsMoreAlertsCountValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object ConditionAlerts
func (fpv *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		if _, ok := (*target).Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); !ok {
			(*target).Type = &NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition{}
		}
		(*target).Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition).TimeSeriesCondition = fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		if _, ok := (*target).Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); !ok {
			(*target).Type = &NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition{}
		}
		(*target).Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition).LogCondition = fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		(*target).Alerts = fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
		(*target).MoreAlertsCount = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue' with the value under path in 'NotificationMsg_AlertsGroup_ConditionAlerts'.
func (fpv *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts) (int, bool) {
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
		leftValue := fpv.value.(int32)
		rightValue := source.GetMoreAlertsCount()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fpv.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlerts_FieldSubPathValue struct {
	NotificationMsgAlertsGroupConditionAlerts_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsgAlertsGroupConditionAlerts_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlerts_FieldSubPathValue)(nil)

func (fpvs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathValue) AsTimeSeriesConditionPathValue() (NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathValue) AsLogConditionPathValue() (NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathValue) AsAlertsPathValue() (NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts)
	}
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		if _, ok := (*target).Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition); !ok {
			(*target).Type = &NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition{}
		}
		fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue).SetTo(&(*target).Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_TimeSeriesCondition).TimeSeriesCondition)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		if _, ok := (*target).Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition); !ok {
			(*target).Type = &NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition{}
		}
		fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue).SetTo(&(*target).Type.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCondition).LogCondition)
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts) (int, bool) {
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		return fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue).CompareWith(source.GetTimeSeriesCondition())
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		return fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue).CompareWith(source.GetLogCondition())
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlerts_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlerts_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ConditionAlerts'
func (fpaiv *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts) bool {
	slice := fpaiv.NotificationMsgAlertsGroupConditionAlerts_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 NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlerts_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayItemValue) AsTimeSeriesConditionPathItemValue() (NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayItemValue) AsLogConditionPathItemValue() (NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayItemValue) AsAlertsPathItemValue() (NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ConditionAlerts'
func (fpaivs *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts) bool {
	switch fpaivs.Selector() {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayItemValue).ContainsValue(source.GetTimeSeriesCondition())
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayItemValue).ContainsValue(source.GetLogCondition())
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts: %d", fpaivs.Selector()))
	}
}

// NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues allows storing slice of values for ConditionAlerts fields according to their type
type NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlerts_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorTimeSeriesCondition:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorLogCondition:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorAlerts:
		for _, v := range fpaov.values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlerts_FieldPathSelectorMoreAlertsCount:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues) AsTimeSeriesConditionArrayOfValues() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues) AsLogConditionArrayOfValues() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues) AsAlertsArrayOfValues() ([][]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert, bool) {
	res, ok := fpaov.values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlerts_FieldTerminalPathArrayOfValues) AsMoreAlertsCountArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

type NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlerts_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsgAlertsGroupConditionAlerts_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayOfValues) AsTimeSeriesConditionPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayOfValues) AsLogConditionPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlerts_FieldSubPathArrayOfValues) AsAlertsPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn         NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector = 1
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries     NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector = 2
)

func (s NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
		return "fqn"
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
		return "display_name"
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
		return "queries"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "fqn":
			return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn}, nil
		case "display_name", "displayName", "display-name":
			return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName}, nil
		case "queries":
			return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries}, nil
		}
	} else {
		switch fp[0] {
		case "queries":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType
func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
			if source.Fqn != nil {
				values = append(values, source.Fqn)
			}
		case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
			values = append(values, source.DisplayName)
		case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
			for _, value := range source.GetQueries() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType
func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
		res := source.GetFqn()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
		return source.GetDisplayName(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
		res := source.GetQueries()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
		return (*ts_condition.Name)(nil)
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
		return ""
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
		return ([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
			item.Fqn = nil
		case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
			item.DisplayName = ""
		case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
			item.Queries = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath: *fp, value: value.(*ts_condition.Name)}
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath: *fp, value: value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath: *fp, values: values.([]*ts_condition.Name)}
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath: *fp, values: values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayItemValue{NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", fp.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath)(nil)

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath) Selector() NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath) AsQueriesSubPath() (NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType))
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue {
	return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues {
	return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayItemValue {
	return &NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue allows storing values for TsCndType fields according to their type
type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TsCndType' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue) AsFqnValue() (*ts_condition.Name, bool) {
	res, ok := fpv.value.(*ts_condition.Name)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue) AsDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue) AsQueriesValue() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query, bool) {
	res, ok := fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)
	return res, ok
}

// SetTo stores value for selected field for object TsCndType
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
		(*target).Fqn = fpv.value.(*ts_condition.Name)
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
		(*target).DisplayName = fpv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
		(*target).Queries = fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue' with the value under path in 'NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType'.
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) (int, bool) {
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
		leftValue := fpv.value.(*ts_condition.Name)
		rightValue := source.GetFqn()
		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 NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
		leftValue := fpv.value.(string)
		rightValue := source.GetDisplayName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType: %d", fpv.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathValue)(nil)

func (fpvs *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathValue) AsQueriesPathValue() (NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType as interface{}
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayItemValue) AsQueriesItemValue() (*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query, bool) {
	res, ok := fpaiv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)
	return res, ok
}

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'TsCndType'
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType) bool {
	slice := fpaiv.NotificationMsgAlertsGroupConditionAlertsTsCndType_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 NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues allows storing slice of values for TsCndType fields according to their type
type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorFqn:
		for _, v := range fpaov.values.([]*ts_condition.Name) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathSelectorQueries:
		for _, v := range fpaov.values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues) AsFqnArrayOfValues() ([]*ts_condition.Name, bool) {
	res, ok := fpaov.values.([]*ts_condition.Name)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues) AsDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldTerminalPathArrayOfValues) AsQueriesArrayOfValues() ([][]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query, bool) {
	res, ok := fpaov.values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)
	return res, ok
}

type NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsTsCndType_FieldSubPathArrayOfValues) AsQueriesPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn         NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector = 1
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries     NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector = 2
)

func (s NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
		return "fqn"
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
		return "display_name"
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
		return "queries"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "fqn":
			return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn}, nil
		case "display_name", "displayName", "display-name":
			return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName}, nil
		case "queries":
			return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries}, nil
		}
	} else {
		switch fp[0] {
		case "queries":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType
func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
			if source.Fqn != nil {
				values = append(values, source.Fqn)
			}
		case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
			values = append(values, source.DisplayName)
		case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
			for _, value := range source.GetQueries() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType
func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
		res := source.GetFqn()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
		return source.GetDisplayName(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
		res := source.GetQueries()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
		return (*log_condition.Name)(nil)
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
		return ""
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
		return ([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
			item.Fqn = nil
		case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
			item.DisplayName = ""
		case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
			item.Queries = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath: *fp, value: value.(*log_condition.Name)}
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath: *fp, value: value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath: *fp, values: values.([]*log_condition.Name)}
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath: *fp, values: values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayItemValue{NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", fp.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath)(nil)

func (fps *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath) Selector() NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath) AsQueriesSubPath() (NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType))
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue {
	return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues {
	return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayItemValue {
	return &NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue allows storing values for LogCndType fields according to their type
type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'LogCndType' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue) AsFqnValue() (*log_condition.Name, bool) {
	res, ok := fpv.value.(*log_condition.Name)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue) AsDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue) AsQueriesValue() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query, bool) {
	res, ok := fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)
	return res, ok
}

// SetTo stores value for selected field for object LogCndType
func (fpv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
		(*target).Fqn = fpv.value.(*log_condition.Name)
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
		(*target).DisplayName = fpv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
		(*target).Queries = fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue' with the value under path in 'NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType'.
func (fpv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) (int, bool) {
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
		leftValue := fpv.value.(*log_condition.Name)
		rightValue := source.GetFqn()
		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 NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
		leftValue := fpv.value.(string)
		rightValue := source.GetDisplayName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType: %d", fpv.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathValue)(nil)

func (fpvs *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathValue) AsQueriesPathValue() (NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType as interface{}
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayItemValue) AsQueriesItemValue() (*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query, bool) {
	res, ok := fpaiv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)
	return res, ok
}

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'LogCndType'
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType) bool {
	slice := fpaiv.NotificationMsgAlertsGroupConditionAlertsLogCndType_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 NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues allows storing slice of values for LogCndType fields according to their type
type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorFqn:
		for _, v := range fpaov.values.([]*log_condition.Name) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathSelectorQueries:
		for _, v := range fpaov.values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues) AsFqnArrayOfValues() ([]*log_condition.Name, bool) {
	res, ok := fpaov.values.([]*log_condition.Name)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues) AsDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldTerminalPathArrayOfValues) AsQueriesArrayOfValues() ([][]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query, bool) {
	res, ok := fpaov.values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)
	return res, ok
}

type NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsLogCndType_FieldSubPathArrayOfValues) AsQueriesPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType             NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn              NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 1
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName      NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 2
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring         NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 3
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime        NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 4
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime         NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 5
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification   NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 6
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo    NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 7
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel  NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 8
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling       NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 9
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector = 10
)

func (s NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
		return "type"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
		return "fqn"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
		return "display_name"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
		return "is_firing"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
		return "start_time"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
		return "stop_time"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		return "identification"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		return "violation_info"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
		return "escalation_level"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		return "ai_handling"
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		return "operator_handling"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsAlert_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType}, nil
		case "fqn":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn}, nil
		case "display_name", "displayName", "display-name":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName}, nil
		case "is_firing", "isFiring", "is-firing":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring}, nil
		case "start_time", "startTime", "start-time":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime}, nil
		case "stop_time", "stopTime", "stop-time":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime}, nil
		case "identification":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification}, nil
		case "violation_info", "violationInfo", "violation-info":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo}, nil
		case "escalation_level", "escalationLevel", "escalation-level":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel}, nil
		case "ai_handling", "aiHandling", "ai-handling":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling}, nil
		case "operator_handling", "operatorHandling", "operator-handling":
			return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling}, nil
		}
	} else {
		switch fp[0] {
		case "identification":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification, subPath: subpath}, nil
			}
		case "violation_info", "violationInfo", "violation-info":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo, subPath: subpath}, nil
			}
		case "ai_handling", "aiHandling", "ai-handling":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling, subPath: subpath}, nil
			}
		case "operator_handling", "operatorHandling", "operator-handling":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsAlert_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert
func (fp *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
			values = append(values, source.Type)
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
			if source.Fqn != nil {
				values = append(values, source.Fqn)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
			values = append(values, source.DisplayName)
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
			values = append(values, source.IsFiring)
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
			if source.StartTime != nil {
				values = append(values, source.StartTime)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
			if source.StopTime != nil {
				values = append(values, source.StopTime)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
			if source.Identification != nil {
				values = append(values, source.Identification)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
			if source.ViolationInfo != nil {
				values = append(values, source.ViolationInfo)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
			values = append(values, source.EscalationLevel)
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
			if source.AiHandling != nil {
				values = append(values, source.AiHandling)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
			if source.OperatorHandling != nil {
				values = append(values, source.OperatorHandling)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert
func (fp *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
		return source.GetType(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
		res := source.GetFqn()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
		return source.GetDisplayName(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
		return source.GetIsFiring(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
		res := source.GetStartTime()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
		res := source.GetStopTime()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		res := source.GetIdentification()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		res := source.GetViolationInfo()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
		return source.GetEscalationLevel(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		res := source.GetAiHandling()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		res := source.GetOperatorHandling()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
		return NotificationMsg_AlertsGroup_ConditionAlerts_Alert_UNDEFINED
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
		return (*alert.Name)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
		return ""
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
		return false
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
		return (*timestamppb.Timestamp)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
		return (*timestamppb.Timestamp)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		return (*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		return (*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
		return alert.Alert_State_NONE
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		return (*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		return (*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
			item.Type = NotificationMsg_AlertsGroup_ConditionAlerts_Alert_UNDEFINED
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
			item.Fqn = nil
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
			item.DisplayName = ""
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
			item.IsFiring = false
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
			item.StartTime = nil
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
			item.StopTime = nil
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
			item.Identification = nil
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
			item.ViolationInfo = nil
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
			item.EscalationLevel = alert.Alert_State_NONE
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
			item.AiHandling = nil
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
			item.OperatorHandling = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Type)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(*alert.Name)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(bool)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(alert.Alert_State_EscalationLevel)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Type)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]*alert.Name)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]bool)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]alert.Alert_State_EscalationLevel)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath: *fp, values: values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath)(nil)

func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) AsIdentificationSubPath() (NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath)
	return res, ok
}
func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) AsViolationInfoSubPath() (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath)
	return res, ok
}
func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) AsAiHandlingSubPath() (NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath)
	return res, ok
}
func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) AsOperatorHandlingSubPath() (NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert
func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) (values []interface{}) {
	switch fps.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		values = append(values, fps.subPath.GetRaw(source.GetIdentification())...)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		values = append(values, fps.subPath.GetRaw(source.GetViolationInfo())...)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		values = append(values, fps.subPath.GetRaw(source.GetAiHandling())...)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		values = append(values, fps.subPath.GetRaw(source.GetOperatorHandling())...)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert
func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) (interface{}, bool) {
	switch fps.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		if source.GetIdentification() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetIdentification())
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		if source.GetViolationInfo() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetViolationInfo())
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		if source.GetAiHandling() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAiHandling())
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		if source.GetOperatorHandling() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetOperatorHandling())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fps.selector))
	}
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) {
	if item != nil {
		switch fps.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
			fps.subPath.ClearValueRaw(item.Identification)
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
			fps.subPath.ClearValueRaw(item.ViolationInfo)
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
			fps.subPath.ClearValueRaw(item.AiHandling)
		case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
			fps.subPath.ClearValueRaw(item.OperatorHandling)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fps.selector))
		}
	}
}

func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert))
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue {
	return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues {
	return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayItemValue {
	return &NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue allows storing values for Alert fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Alert' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsTypeValue() (NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Type, bool) {
	res, ok := fpv.value.(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Type)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsFqnValue() (*alert.Name, bool) {
	res, ok := fpv.value.(*alert.Name)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsIsFiringValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsStartTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsStopTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsIdentificationValue() (*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsViolationInfoValue() (*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsEscalationLevelValue() (alert.Alert_State_EscalationLevel, bool) {
	res, ok := fpv.value.(alert.Alert_State_EscalationLevel)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsAiHandlingValue() (*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) AsOperatorHandlingValue() (*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling, bool) {
	res, ok := fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling)
	return res, ok
}

// SetTo stores value for selected field for object Alert
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
		(*target).Type = fpv.value.(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Type)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
		(*target).Fqn = fpv.value.(*alert.Name)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
		(*target).DisplayName = fpv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
		(*target).IsFiring = fpv.value.(bool)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
		(*target).StartTime = fpv.value.(*timestamppb.Timestamp)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
		(*target).StopTime = fpv.value.(*timestamppb.Timestamp)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		(*target).Identification = fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		(*target).ViolationInfo = fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
		(*target).EscalationLevel = fpv.value.(alert.Alert_State_EscalationLevel)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		(*target).AiHandling = fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		(*target).OperatorHandling = fpv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue' with the value under path in 'NotificationMsg_AlertsGroup_ConditionAlerts_Alert'.
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) (int, bool) {
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
		leftValue := fpv.value.(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Type)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
		leftValue := fpv.value.(*alert.Name)
		rightValue := source.GetFqn()
		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 NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
		leftValue := fpv.value.(string)
		rightValue := source.GetDisplayName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsFiring()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetStartTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetStopTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
		leftValue := fpv.value.(alert.Alert_State_EscalationLevel)
		rightValue := source.GetEscalationLevel()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fpv.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathValue)(nil)

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathValue) AsIdentificationPathValue() (NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathValue) AsViolationInfoPathValue() (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathValue) AsAiHandlingPathValue() (NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathValue) AsOperatorHandlingPathValue() (NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert)
	}
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue).SetTo(&(*target).Identification)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue).SetTo(&(*target).ViolationInfo)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue).SetTo(&(*target).AiHandling)
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue).SetTo(&(*target).OperatorHandling)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) (int, bool) {
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		return fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue).CompareWith(source.GetIdentification())
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		return fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue).CompareWith(source.GetViolationInfo())
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		return fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue).CompareWith(source.GetAiHandling())
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		return fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue).CompareWith(source.GetOperatorHandling())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Alert'
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) bool {
	slice := fpaiv.NotificationMsgAlertsGroupConditionAlertsAlert_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 NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayItemValue) AsIdentificationPathItemValue() (NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayItemValue) AsViolationInfoPathItemValue() (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayItemValue) AsAiHandlingPathItemValue() (NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayItemValue) AsOperatorHandlingPathItemValue() (NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Alert'
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert) bool {
	switch fpaivs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayItemValue).ContainsValue(source.GetIdentification())
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayItemValue).ContainsValue(source.GetViolationInfo())
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayItemValue).ContainsValue(source.GetAiHandling())
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		return fpaivs.subPathItemValue.(NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayItemValue).ContainsValue(source.GetOperatorHandling())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert: %d", fpaivs.Selector()))
	}
}

// NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues allows storing slice of values for Alert fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorType:
		for _, v := range fpaov.values.([]NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Type) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorFqn:
		for _, v := range fpaov.values.([]*alert.Name) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIsFiring:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStartTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorStopTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorIdentification:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorViolationInfo:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorEscalationLevel:
		for _, v := range fpaov.values.([]alert.Alert_State_EscalationLevel) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorAiHandling:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathSelectorOperatorHandling:
		for _, v := range fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Type, bool) {
	res, ok := fpaov.values.([]NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Type)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsFqnArrayOfValues() ([]*alert.Name, bool) {
	res, ok := fpaov.values.([]*alert.Name)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsIsFiringArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsStartTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsStopTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsIdentificationArrayOfValues() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsViolationInfoArrayOfValues() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsEscalationLevelArrayOfValues() ([]alert.Alert_State_EscalationLevel, bool) {
	res, ok := fpaov.values.([]alert.Alert_State_EscalationLevel)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsAiHandlingArrayOfValues() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldTerminalPathArrayOfValues) AsOperatorHandlingArrayOfValues() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling, bool) {
	res, ok := fpaov.values.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling)
	return res, ok
}

type NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlert_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsgAlertsGroupConditionAlertsAlert_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayOfValues) AsIdentificationPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayOfValues) AsViolationInfoPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayOfValues) AsAiHandlingPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlert_FieldSubPathArrayOfValues) AsOperatorHandlingPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter      NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector = 1
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector = 2
)

func (s NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
		return "description"
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
		return "filter"
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		return "aggregation"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "description":
			return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription}, nil
		case "filter":
			return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter}, nil
		case "aggregation":
			return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation}, nil
		}
	} else {
		switch fp[0] {
		case "aggregation":
			if subpath, err := monitoring_common.BuildAggregation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query
func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
			values = append(values, source.Filter)
		case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
			if source.Aggregation != nil {
				values = append(values, source.Aggregation)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query
func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
		return source.GetFilter(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		res := source.GetAggregation()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
		return ""
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
		return ""
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		return (*monitoring_common.Aggregation)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
			item.Description = ""
		case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
			item.Filter = ""
		case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
			item.Aggregation = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath: *fp, value: value.(*monitoring_common.Aggregation)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath: *fp, values: values.([]*monitoring_common.Aggregation)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath)(nil)

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath) Selector() NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath) AsAggregationSubPath() (monitoring_common.Aggregation_FieldPath, bool) {
	res, ok := fps.subPath.(monitoring_common.Aggregation_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) {
	if item != nil {
		switch fps.selector {
		case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
			fps.subPath.ClearValueRaw(item.Aggregation)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fps.selector))
		}
	}
}

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query))
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue {
	return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues {
	return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayItemValue {
	return &NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue allows storing values for Query fields according to their type
type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Query' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue) AsFilterValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue) AsAggregationValue() (*monitoring_common.Aggregation, bool) {
	res, ok := fpv.value.(*monitoring_common.Aggregation)
	return res, ok
}

// SetTo stores value for selected field for object Query
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		(*target).Aggregation = fpv.value.(*monitoring_common.Aggregation)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue' with the value under path in 'NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query'.
func (fpv *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) (int, bool) {
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
		leftValue := fpv.value.(string)
		rightValue := source.GetDescription()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
		leftValue := fpv.value.(string)
		rightValue := source.GetFilter()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fpv.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathValue)(nil)

func (fpvs *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathValue) AsAggregationPathValue() (monitoring_common.Aggregation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(monitoring_common.Aggregation_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query)
	}
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		fpvs.subPathValue.(monitoring_common.Aggregation_FieldPathValue).SetTo(&(*target).Aggregation)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) (int, bool) {
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		return fpvs.subPathValue.(monitoring_common.Aggregation_FieldPathValue).CompareWith(source.GetAggregation())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Query'
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) bool {
	slice := fpaiv.NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_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 NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayItemValue) AsAggregationPathItemValue() (monitoring_common.Aggregation_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(monitoring_common.Aggregation_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Query'
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query) bool {
	switch fpaivs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		return fpaivs.subPathItemValue.(monitoring_common.Aggregation_FieldPathArrayItemValue).ContainsValue(source.GetAggregation())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_TsCndType_Query: %d", fpaivs.Selector()))
	}
}

// NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues allows storing slice of values for Query fields according to their type
type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathSelectorAggregation:
		for _, v := range fpaov.values.([]*monitoring_common.Aggregation) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldTerminalPathArrayOfValues) AsAggregationArrayOfValues() ([]*monitoring_common.Aggregation, bool) {
	res, ok := fpaov.values.([]*monitoring_common.Aggregation)
	return res, ok
}

type NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsTsCndTypeQuery_FieldSubPathArrayOfValues) AsAggregationPathArrayOfValues() (monitoring_common.Aggregation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(monitoring_common.Aggregation_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter      NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelector = 1
)

func (s NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription:
		return "description"
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter:
		return "filter"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "description":
			return &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription}, nil
		case "filter":
			return &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query
func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter:
		return source.GetFilter(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query: %d", fp.selector))
	}
}

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

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

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription:
			item.Description = ""
		case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter:
			item.Filter = ""
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter:
		return &NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathValue allows storing values for Query fields according to their type
type NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object Query
func (fpv *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_LogCndType_Query) (interface{}, bool) {
	return nil, false
}

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

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

// NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayOfValues allows storing slice of values for Query fields according to their type
type NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsLogCndTypeQuery_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]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 NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath interface {
	gotenobject.FieldPath
	Selector() NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector
	Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) []interface{}
	GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) (interface{}, bool)
	ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)

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

type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels      NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels   NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector = 1
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector = 2
)

func (s NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		return "log_labels"
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		return "metric_labels"
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		return "resource_labels"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "log_labels", "logLabels", "log-labels":
			return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels}, nil
		case "metric_labels", "metricLabels", "metric-labels":
			return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels}, nil
		case "resource_labels", "resourceLabels", "resource-labels":
			return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels}, nil
		}
	} else {
		switch fp[0] {
		case "log_labels", "logLabels", "log-labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)", fp)
			}
			return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels, key: fp[1]}, nil
		case "metric_labels", "metricLabels", "metric-labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)", fp)
			}
			return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels, key: fp[1]}, nil
		case "resource_labels", "resourceLabels", "resource-labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)", fp)
			}
			return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap{selector: NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
			values = append(values, source.LogLabels)
		case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
			values = append(values, source.MetricLabels)
		case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
			values = append(values, source.ResourceLabels)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		res := source.GetLogLabels()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		res := source.GetMetricLabels()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		res := source.GetResourceLabels()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		return (map[string]string)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		return (map[string]string)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		return (map[string]string)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
			item.LogLabels = nil
		case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
			item.MetricLabels = nil
		case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
			item.ResourceLabels = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath: *fp, value: value.(map[string]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath: *fp, value: value.(map[string]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath: *fp, value: value.(map[string]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// FieldPath for map type with additional Key information
type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap struct {
	key      string
	selector NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap)(nil)

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) Selector() NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelector {
	return fpm.selector
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) Key() string {
	return fpm.key
}

// String returns path representation in proto convention
func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) String() string {
	return fpm.selector.String() + "." + fpm.key
}

// JSONString returns path representation is JSON convention. Note that map keys are not transformed
func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) JSONString() string {
	return strcase.ToLowerCamel(fpm.selector.String()) + "." + fpm.key
}

// Get returns all values pointed by selected field map key from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification
func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) (values []interface{}) {
	switch fpm.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		if value, ok := source.GetLogLabels()[fpm.key]; ok {
			values = append(values, value)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		if value, ok := source.GetMetricLabels()[fpm.key]; ok {
			values = append(values, value)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		if value, ok := source.GetResourceLabels()[fpm.key]; ok {
			values = append(values, value)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpm.selector))
	}
	return
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) GetRaw(source proto.Message) []interface{} {
	return fpm.Get(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification))
}

// GetSingle returns value by selected field map key from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification
func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) (interface{}, bool) {
	switch fpm.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		res, ok := source.GetLogLabels()[fpm.key]
		return res, ok
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		res, ok := source.GetMetricLabels()[fpm.key]
		return res, ok
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		res, ok := source.GetResourceLabels()[fpm.key]
		return res, ok
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpm.selector))
	}
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpm.GetSingle(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification))
}

// GetDefault returns a default value of the field type
func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) GetDefault() interface{} {
	switch fpm.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		var v string
		return v
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		var v string
		return v
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		var v string
		return v
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpm.selector))
	}
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) {
	if item != nil {
		switch fpm.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
			delete(item.LogLabels, fpm.key)
		case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
			delete(item.MetricLabels, fpm.key)
		case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
			delete(item.ResourceLabels, fpm.key)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpm.selector))
		}
	}
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification))
}

// IsLeaf - whether field path is holds simple value
func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) IsLeaf() bool {
	switch fpm.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		return true
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		return true
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		return true
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpm.selector))
	}
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fpm}
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue {
	switch fpm.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap: *fpm, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap: *fpm, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap: *fpm, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpm.selector))
	}
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fpm.WithIValue(value)
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues {
	switch fpm.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap: *fpm, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap: *fpm, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		return &NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap: *fpm, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpm.selector))
	}
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fpm.WithIArrayOfValues(values)
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayItemValue {
	panic("Cannot create array item value from map fieldpath")
}

func (fpm *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fpm.WithIArrayItemValue(value)
}

// NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue allows storing values for Identification fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Identification' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue) AsLogLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue) AsMetricLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue) AsResourceLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}

// SetTo stores value for selected field for object Identification
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		(*target).LogLabels = fpv.value.(map[string]string)
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		(*target).MetricLabels = fpv.value.(map[string]string)
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		(*target).ResourceLabels = fpv.value.(map[string]string)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpv.selector))
	}
}

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

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

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

type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue)(nil)

// GetValue returns value stored under selected field in Identification as interface{}
func (fpmv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue) GetRawValue() interface{} {
	return fpmv.value
}
func (fpmv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue) AsLogLabelsElementValue() (string, bool) {
	res, ok := fpmv.value.(string)
	return res, ok
}
func (fpmv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue) AsMetricLabelsElementValue() (string, bool) {
	res, ok := fpmv.value.(string)
	return res, ok
}
func (fpmv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue) AsResourceLabelsElementValue() (string, bool) {
	res, ok := fpmv.value.(string)
	return res, ok
}

// SetTo stores value for selected field in Identification
func (fpmv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)
	}
	switch fpmv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		if (*target).LogLabels == nil {
			(*target).LogLabels = make(map[string]string)
		}
		(*target).LogLabels[fpmv.key] = fpmv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		if (*target).MetricLabels == nil {
			(*target).MetricLabels = make(map[string]string)
		}
		(*target).MetricLabels[fpmv.key] = fpmv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		if (*target).ResourceLabels == nil {
			(*target).ResourceLabels = make(map[string]string)
		}
		(*target).ResourceLabels[fpmv.key] = fpmv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpmv.selector))
	}
}

func (fpmv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue) SetToRaw(target proto.Message) {
	typedObject := target.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification)
	fpmv.SetTo(&typedObject)
}

// CompareWith compares value in the 'NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue' with the value under path in 'NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification'.
func (fpmv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) (int, bool) {
	switch fpmv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		leftValue := fpmv.value.(string)
		rightValue := source.GetLogLabels()[fpmv.key]
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		leftValue := fpmv.value.(string)
		rightValue := source.GetMetricLabels()[fpmv.key]
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		leftValue := fpmv.value.(string)
		rightValue := source.GetResourceLabels()[fpmv.key]
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification: %d", fpmv.selector))
	}
}

func (fpmv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpmv.CompareWith(source.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification))
}

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_Identification) (interface{}, bool) {
	return nil, false
}

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

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

// NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues allows storing slice of values for Identification fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues) AsLogLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues) AsMetricLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldTerminalPathArrayOfValues) AsResourceLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}

type NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMap
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapArrayOfValues)(nil)

func (fpmaov *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpmaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorLogLabels:
		for _, v := range fpmaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorMetricLabels:
		for _, v := range fpmaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathSelectorResourceLabels:
		for _, v := range fpmaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpmaov *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapArrayOfValues) AsLogLabelsArrayOfElementValues() ([]string, bool) {
	res, ok := fpmaov.values.([]string)
	return res, ok
}
func (fpmaov *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapArrayOfValues) AsMetricLabelsArrayOfElementValues() ([]string, bool) {
	res, ok := fpmaov.values.([]string)
	return res, ok
}
func (fpmaov *NotificationMsgAlertsGroupConditionAlertsAlertIdentification_FieldPathMapArrayOfValues) AsResourceLabelsArrayOfElementValues() ([]string, bool) {
	res, ok := fpmaov.values.([]string)
	return res, ok
}

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

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

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue   NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector = 1
)

func (s NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue:
		return "log_value"
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
		return "time_series"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "log_value", "logValue", "log-value":
			return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue}, nil
		case "time_series", "timeSeries", "time-series":
			return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries}, nil
		}
	} else {
		switch fp[0] {
		case "time_series", "timeSeries", "time-series":
			if subpath, err := BuildNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue:
		return ""
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
		return ([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue:
			item.LogValue = ""
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
			item.TimeSeries = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo))
}

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

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath: *fp, value: value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath: *fp, values: values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayItemValue{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath: *fp, value: value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo: %d", fp.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath)(nil)

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath) AsTimeSeriesSubPath() (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath, bool) {
	res, ok := fps.subPath.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo))
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue {
	return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues {
	return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayItemValue {
	return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue allows storing values for ViolationInfo fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ViolationInfo' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathValue) AsLogValueValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathValue) AsTimeSeriesValue() ([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries, bool) {
	res, ok := fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)
	return res, ok
}

// SetTo stores value for selected field for object ViolationInfo
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue:
		(*target).LogValue = fpv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
		(*target).TimeSeries = fpv.value.([]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo: %d", fpv.selector))
	}
}

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

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

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

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathValue)(nil)

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathValue) AsTimeSeriesPathValue() (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo as interface{}
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayItemValue) AsTimeSeriesItemValue() (*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries, bool) {
	res, ok := fpaiv.value.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)
	return res, ok
}

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ViolationInfo'
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo) bool {
	slice := fpaiv.NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_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 NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues allows storing slice of values for ViolationInfo fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorLogValue:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathSelectorTimeSeries:
		for _, v := range fpaov.values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayOfValues) AsLogValueArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([][]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries, bool) {
	res, ok := fpaov.values.([][]*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)
	return res, ok
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfo_FieldSubPathArrayOfValues) AsTimeSeriesPathArrayOfValues() (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState         NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector = 1
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation        NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector = 2
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg       NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector = 3
)

func (s NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
		return "current_state"
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
		return "troubleshooting_notes"
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		return "ai_remediation"
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
		return "remediation_arg"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "current_state", "currentState", "current-state":
			return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState}, nil
		case "troubleshooting_notes", "troubleshootingNotes", "troubleshooting-notes":
			return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes}, nil
		case "ai_remediation", "aiRemediation", "ai-remediation":
			return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation}, nil
		case "remediation_arg", "remediationArg", "remediation-arg":
			return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg}, nil
		}
	} else {
		switch fp[0] {
		case "ai_remediation", "aiRemediation", "ai-remediation":
			if subpath, err := rcommon.BuildPolicySpecAIAgentHandlingRemediation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
			values = append(values, source.CurrentState)
		case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
			values = append(values, source.TroubleshootingNotes)
		case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
			if source.AiRemediation != nil {
				values = append(values, source.AiRemediation)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
			values = append(values, source.RemediationArg)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
		return source.GetCurrentState(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
		return source.GetTroubleshootingNotes(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		res := source.GetAiRemediation()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
		return source.GetRemediationArg(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
		return alert.Alert_State_AI_AGENT_NOT_INVOLVED
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
		return ""
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		return (*rcommon.PolicySpec_AIAgentHandling_Remediation)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
			item.CurrentState = alert.Alert_State_AI_AGENT_NOT_INVOLVED
		case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
			item.TroubleshootingNotes = ""
		case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
			item.AiRemediation = nil
		case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
			item.RemediationArg = ""
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
		return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath: *fp, value: value.(alert.Alert_State_AiHandlingState)}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
		return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath: *fp, value: value.(*rcommon.PolicySpec_AIAgentHandling_Remediation)}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
		return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
		return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath: *fp, values: values.([]alert.Alert_State_AiHandlingState)}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
		return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath: *fp, values: values.([]*rcommon.PolicySpec_AIAgentHandling_Remediation)}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
		return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath)(nil)

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath) AsAiRemediationSubPath() (rcommon.PolicySpecAIAgentHandlingRemediation_FieldPath, bool) {
	res, ok := fps.subPath.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) {
	if item != nil {
		switch fps.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
			fps.subPath.ClearValueRaw(item.AiRemediation)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fps.selector))
		}
	}
}

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling))
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue {
	return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues {
	return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayItemValue {
	return &NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue allows storing values for AiHandling fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AiHandling' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue) AsCurrentStateValue() (alert.Alert_State_AiHandlingState, bool) {
	res, ok := fpv.value.(alert.Alert_State_AiHandlingState)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue) AsTroubleshootingNotesValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue) AsAiRemediationValue() (*rcommon.PolicySpec_AIAgentHandling_Remediation, bool) {
	res, ok := fpv.value.(*rcommon.PolicySpec_AIAgentHandling_Remediation)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue) AsRemediationArgValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object AiHandling
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
		(*target).CurrentState = fpv.value.(alert.Alert_State_AiHandlingState)
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
		(*target).TroubleshootingNotes = fpv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		(*target).AiRemediation = fpv.value.(*rcommon.PolicySpec_AIAgentHandling_Remediation)
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
		(*target).RemediationArg = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue' with the value under path in 'NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling'.
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) (int, bool) {
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
		leftValue := fpv.value.(alert.Alert_State_AiHandlingState)
		rightValue := source.GetCurrentState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
		leftValue := fpv.value.(string)
		rightValue := source.GetTroubleshootingNotes()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
		leftValue := fpv.value.(string)
		rightValue := source.GetRemediationArg()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fpv.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathValue)(nil)

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathValue) AsAiRemediationPathValue() (rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling)
	}
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		fpvs.subPathValue.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathValue).SetTo(&(*target).AiRemediation)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) (int, bool) {
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		return fpvs.subPathValue.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathValue).CompareWith(source.GetAiRemediation())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'AiHandling'
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) bool {
	slice := fpaiv.NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_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 NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayItemValue) AsAiRemediationPathItemValue() (rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'AiHandling'
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling) bool {
	switch fpaivs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		return fpaivs.subPathItemValue.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue).ContainsValue(source.GetAiRemediation())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_AiHandling: %d", fpaivs.Selector()))
	}
}

// NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues allows storing slice of values for AiHandling fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorCurrentState:
		for _, v := range fpaov.values.([]alert.Alert_State_AiHandlingState) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorTroubleshootingNotes:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorAiRemediation:
		for _, v := range fpaov.values.([]*rcommon.PolicySpec_AIAgentHandling_Remediation) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathSelectorRemediationArg:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues) AsCurrentStateArrayOfValues() ([]alert.Alert_State_AiHandlingState, bool) {
	res, ok := fpaov.values.([]alert.Alert_State_AiHandlingState)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues) AsTroubleshootingNotesArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues) AsAiRemediationArrayOfValues() ([]*rcommon.PolicySpec_AIAgentHandling_Remediation, bool) {
	res, ok := fpaov.values.([]*rcommon.PolicySpec_AIAgentHandling_Remediation)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldTerminalPathArrayOfValues) AsRemediationArgArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

type NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlertAiHandling_FieldSubPathArrayOfValues) AsAiRemediationPathArrayOfValues() (rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues)
	return res, ok
}

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

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

type NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes        NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelector = 1
)

func (s NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
		return "current_state"
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
		return "notes"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "current_state", "currentState", "current-state":
			return &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState}, nil
		case "notes":
			return &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
		return source.GetCurrentState(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
		return source.GetNotes(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
		return alert.Alert_State_OP_NOT_INVOLVED
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
			item.CurrentState = alert.Alert_State_OP_NOT_INVOLVED
		case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
			item.Notes = ""
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
		return &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath: *fp, value: value.(alert.Alert_State_OperatorHandlingState)}
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
		return &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
		return &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath: *fp, values: values.([]alert.Alert_State_OperatorHandlingState)}
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
		return &NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue allows storing values for OperatorHandling fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'OperatorHandling' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue) AsCurrentStateValue() (alert.Alert_State_OperatorHandlingState, bool) {
	res, ok := fpv.value.(alert.Alert_State_OperatorHandlingState)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue) AsNotesValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object OperatorHandling
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
		(*target).CurrentState = fpv.value.(alert.Alert_State_OperatorHandlingState)
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
		(*target).Notes = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue' with the value under path in 'NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling'.
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) (int, bool) {
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
		leftValue := fpv.value.(alert.Alert_State_OperatorHandlingState)
		rightValue := source.GetCurrentState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
		leftValue := fpv.value.(string)
		rightValue := source.GetNotes()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling: %d", fpv.selector))
	}
}

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_OperatorHandling) (interface{}, bool) {
	return nil, false
}

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

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

// NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayOfValues allows storing slice of values for OperatorHandling fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorCurrentState:
		for _, v := range fpaov.values.([]alert.Alert_State_OperatorHandlingState) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldPathSelectorNotes:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayOfValues) AsCurrentStateArrayOfValues() ([]alert.Alert_State_OperatorHandlingState, bool) {
	res, ok := fpaov.values.([]alert.Alert_State_OperatorHandlingState)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertOperatorHandling_FieldTerminalPathArrayOfValues) AsNotesArrayOfValues() ([]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 NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath interface {
	gotenobject.FieldPath
	Selector() NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector
	Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) []interface{}
	GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) (interface{}, bool)
	ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)

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

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector int32

const (
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery          NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector = 0
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues         NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector = 1
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector = 2
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector = 3
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter    NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector = 4
)

func (s NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector) String() string {
	switch s {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
		return "query"
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
		return "values"
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return "upper_threshold"
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return "lower_threshold"
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
		return "raised_after"
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", s))
	}
}

func BuildNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath(fp gotenobject.RawFieldPath) (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "query":
			return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery}, nil
		case "values":
			return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues}, nil
		case "upper_threshold", "upperThreshold", "upper-threshold":
			return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold}, nil
		case "lower_threshold", "lowerThreshold", "lower-threshold":
			return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold}, nil
		case "raised_after", "raisedAfter", "raised-after":
			return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter}, nil
		}
	} else {
		switch fp[0] {
		case "upper_threshold", "upperThreshold", "upper-threshold":
			if subpath, err := rcommon.BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold, subPath: subpath}, nil
			}
		case "lower_threshold", "lowerThreshold", "lower-threshold":
			if subpath, err := rcommon.BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath{selector: NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries", fp)
}

func ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath(rawField string) (NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath(fp)
}

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath(rawField string) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath {
	fp, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath)(nil)

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) Get(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
			values = append(values, source.Query)
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
			for _, value := range source.GetValues() {
				values = append(values, value)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
			if source.UpperThreshold != nil {
				values = append(values, source.UpperThreshold)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
			if source.LowerThreshold != nil {
				values = append(values, source.LowerThreshold)
			}
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
			if source.RaisedAfter != nil {
				values = append(values, source.RaisedAfter)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) (interface{}, bool) {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
		return source.GetQuery(), source != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
		res := source.GetValues()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		res := source.GetUpperThreshold()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		res := source.GetLowerThreshold()
		return res, res != nil
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
		res := source.GetRaisedAfter()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
		return ""
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
		return ([]float64)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return (*rcommon.AlertingThreshold)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return (*rcommon.AlertingThreshold)(nil)
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
		return (*durationpb.Duration)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fp.selector))
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) {
	if item != nil {
		switch fp.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
			item.Query = ""
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
			item.Values = nil
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
			item.UpperThreshold = nil
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
			item.LowerThreshold = nil
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
			item.RaisedAfter = nil
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fp.selector))
		}
	}
}

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries))
}

// IsLeaf - whether field path is holds simple value
func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues ||
		fp.selector == NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, value: value.(string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, value: value.([]float64)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, value: value.(*rcommon.AlertingThreshold)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, value: value.(*rcommon.AlertingThreshold)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fp.selector))
	}
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues {
	fpaov := &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp}
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, values: values.([]string)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, values: values.([][]float64)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, values: values.([]*rcommon.AlertingThreshold)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, values: values.([]*rcommon.AlertingThreshold)}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayItemValue {
	switch fp.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
		return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayItemValue{NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath: *fp, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fp.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath struct {
	selector NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath)(nil)

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath) Selector() NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelector {
	return fps.selector
}
func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath) AsUpperThresholdSubPath() (rcommon.AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(rcommon.AlertingThreshold_FieldPath)
	return res, ok
}
func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath) AsLowerThresholdSubPath() (rcommon.AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(rcommon.AlertingThreshold_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath) ClearValue(item *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) {
	if item != nil {
		switch fps.selector {
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
			fps.subPath.ClearValueRaw(item.UpperThreshold)
		case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
			fps.subPath.ClearValueRaw(item.LowerThreshold)
		default:
			panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fps.selector))
		}
	}
}

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries))
}

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

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath) WithIValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue {
	return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath) WithIArrayOfValues(values interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues {
	return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPath) WithIArrayItemValue(value interface{}) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayItemValue {
	return &NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue allows storing values for TimeSeries fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue interface {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)
	CompareWith(*NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) (cmp int, comparable bool)
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue {
	fpv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TimeSeries' as interface{}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue) AsQueryValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue) AsValuesValue() ([]float64, bool) {
	res, ok := fpv.value.([]float64)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue) AsUpperThresholdValue() (*rcommon.AlertingThreshold, bool) {
	res, ok := fpv.value.(*rcommon.AlertingThreshold)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue) AsLowerThresholdValue() (*rcommon.AlertingThreshold, bool) {
	res, ok := fpv.value.(*rcommon.AlertingThreshold)
	return res, ok
}
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue) AsRaisedAfterValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}

// SetTo stores value for selected field for object TimeSeries
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)
	}
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
		(*target).Query = fpv.value.(string)
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
		(*target).Values = fpv.value.([]float64)
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		(*target).UpperThreshold = fpv.value.(*rcommon.AlertingThreshold)
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		(*target).LowerThreshold = fpv.value.(*rcommon.AlertingThreshold)
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
		(*target).RaisedAfter = fpv.value.(*durationpb.Duration)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue' with the value under path in 'NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries'.
func (fpv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) (int, bool) {
	switch fpv.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
		leftValue := fpv.value.(string)
		rightValue := source.GetQuery()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return 0, false
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetRaisedAfter()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fpv.selector))
	}
}

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

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathValue = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathValue)(nil)

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathValue) AsUpperThresholdPathValue() (rcommon.AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue)
	return res, ok
}
func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathValue) AsLowerThresholdPathValue() (rcommon.AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue)
	return res, ok
}

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathValue) SetTo(target **NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) {
	if *target == nil {
		*target = new(NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries)
	}
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).SetTo(&(*target).UpperThreshold)
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).SetTo(&(*target).LowerThreshold)
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathValue) CompareWith(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) (int, bool) {
	switch fpvs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).CompareWith(source.GetUpperThreshold())
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).CompareWith(source.GetLowerThreshold())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayItemValue {
	fpaiv, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath
	value interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayItemValue = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries as interface{}
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayItemValue) AsValuesItemValue() (float64, bool) {
	res, ok := fpaiv.value.(float64)
	return res, ok
}

func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayItemValue) GetSingle(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'TimeSeries'
func (fpaiv *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) bool {
	slice := fpaiv.NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_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 NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayItemValue struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayItemValue) AsUpperThresholdPathItemValue() (rcommon.AlertingThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayItemValue) AsLowerThresholdPathItemValue() (rcommon.AlertingThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'TimeSeries'
func (fpaivs *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayItemValue) ContainsValue(source *NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries) bool {
	switch fpaivs.Selector() {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetUpperThreshold())
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetLowerThreshold())
	default:
		panic(fmt.Sprintf("Invalid selector for NotificationMsg_AlertsGroup_ConditionAlerts_Alert_ViolationInfo_TimeSeries: %d", fpaivs.Selector()))
	}
}

// NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues allows storing slice of values for TimeSeries fields according to their type
type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath
}

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

func MustParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues {
	fpaov, err := ParseNotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPath
	values interface{}
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorQuery:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorValues:
		for _, v := range fpaov.values.([][]float64) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorUpperThreshold:
		for _, v := range fpaov.values.([]*rcommon.AlertingThreshold) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorLowerThreshold:
		for _, v := range fpaov.values.([]*rcommon.AlertingThreshold) {
			values = append(values, v)
		}
	case NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathSelectorRaisedAfter:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues) AsQueryArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues) AsValuesArrayOfValues() ([][]float64, bool) {
	res, ok := fpaov.values.([][]float64)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues) AsUpperThresholdArrayOfValues() ([]*rcommon.AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*rcommon.AlertingThreshold)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues) AsLowerThresholdArrayOfValues() ([]*rcommon.AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*rcommon.AlertingThreshold)
	return res, ok
}
func (fpaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldTerminalPathArrayOfValues) AsRaisedAfterArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}

type NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayOfValues struct {
	NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldPathArrayOfValues = (*NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayOfValues)(nil)

func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayOfValues) AsUpperThresholdPathArrayOfValues() (rcommon.AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rcommon.AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *NotificationMsgAlertsGroupConditionAlertsAlertViolationInfoTimeSeries_FieldSubPathArrayOfValues) AsLowerThresholdPathArrayOfValues() (rcommon.AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rcommon.AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}